--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dietmar Maurer <dietmar@proxmox.com>
+Date: Mon, 6 Apr 2020 12:16:57 +0200
+Subject: [PATCH] PVE-Backup: add vma backup format code
+
+---
+ Makefile | 3 +-
+ Makefile.objs | 1 +
+ vma-reader.c | 857 ++++++++++++++++++++++++++++++++++++++++++++++++++
+ vma-writer.c | 790 ++++++++++++++++++++++++++++++++++++++++++++++
+ vma.c | 839 ++++++++++++++++++++++++++++++++++++++++++++++++
+ vma.h | 150 +++++++++
+ 6 files changed, 2639 insertions(+), 1 deletion(-)
+ create mode 100644 vma-reader.c
+ create mode 100644 vma-writer.c
+ create mode 100644 vma.c
+ create mode 100644 vma.h
+
+diff --git a/Makefile b/Makefile
+index 13dd708c4a..7b8c17ce2d 100644
+--- a/Makefile
++++ b/Makefile
+@@ -479,7 +479,7 @@ dummy := $(call unnest-vars,, \
+
+ include $(SRC_PATH)/tests/Makefile.include
+
+-all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
++all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) vma$(EXESUF) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
+
+ qemu-version.h: FORCE
+ $(call quiet-command, \
+@@ -602,6 +602,7 @@ qemu-img$(EXESUF): qemu-img.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io
+ qemu-nbd$(EXESUF): qemu-nbd.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
+ qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
+ qemu-storage-daemon$(EXESUF): qemu-storage-daemon.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(chardev-obj-y) $(io-obj-y) $(qom-obj-y) $(storage-daemon-obj-y) $(COMMON_LDADDS)
++vma$(EXESUF): vma.o vma-reader.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
+
+ qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
+
+diff --git a/Makefile.objs b/Makefile.objs
+index a1307c12a8..ade7b17a69 100644
+--- a/Makefile.objs
++++ b/Makefile.objs
+@@ -17,6 +17,7 @@ block-obj-y = block/ nbd/ scsi/
+ block-obj-y += block.o blockjob.o job.o
+ block-obj-y += qemu-io-cmds.o
+ block-obj-$(CONFIG_REPLICATION) += replication.o
++block-obj-y += vma-writer.o
+
+ block-obj-m = block/
+
+diff --git a/vma-reader.c b/vma-reader.c
+new file mode 100644
+index 0000000000..2b1d1cdab3
+--- /dev/null
++++ b/vma-reader.c
+@@ -0,0 +1,857 @@
++/*
++ * VMA: Virtual Machine Archive
++ *
++ * Copyright (C) 2012 Proxmox Server Solutions
++ *
++ * Authors:
++ * Dietmar Maurer (dietmar@proxmox.com)
++ *
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++ * See the COPYING file in the top-level directory.
++ *
++ */
++
++#include "qemu/osdep.h"
++#include <glib.h>
++#include <uuid/uuid.h>
++
++#include "qemu-common.h"
++#include "qemu/timer.h"
++#include "qemu/ratelimit.h"
++#include "vma.h"
++#include "block/block.h"
++#include "sysemu/block-backend.h"
++
++static unsigned char zero_vma_block[VMA_BLOCK_SIZE];
++
++typedef struct VmaRestoreState {
++ BlockBackend *target;
++ bool write_zeroes;
++ unsigned long *bitmap;
++ int bitmap_size;
++} VmaRestoreState;
++
++struct VmaReader {
++ int fd;
++ GChecksum *md5csum;
++ GHashTable *blob_hash;
++ unsigned char *head_data;
++ VmaDeviceInfo devinfo[256];
++ VmaRestoreState rstate[256];
++ GList *cdata_list;
++ guint8 vmstate_stream;
++ uint32_t vmstate_clusters;
++ /* to show restore percentage if run with -v */
++ time_t start_time;
++ int64_t cluster_count;
++ int64_t clusters_read;
++ int64_t zero_cluster_data;
++ int64_t partial_zero_cluster_data;
++ int clusters_read_per;
++};
++
++static guint
++g_int32_hash(gconstpointer v)
++{
++ return *(const uint32_t *)v;
++}
++
++static gboolean
++g_int32_equal(gconstpointer v1, gconstpointer v2)
++{
++ return *((const uint32_t *)v1) == *((const uint32_t *)v2);
++}
++
++static int vma_reader_get_bitmap(VmaRestoreState *rstate, int64_t cluster_num)
++{
++ assert(rstate);
++ assert(rstate->bitmap);
++
++ unsigned long val, idx, bit;
++
++ idx = cluster_num / BITS_PER_LONG;
++
++ assert(rstate->bitmap_size > idx);
++
++ bit = cluster_num % BITS_PER_LONG;
++ val = rstate->bitmap[idx];
++
++ return !!(val & (1UL << bit));
++}
++
++static void vma_reader_set_bitmap(VmaRestoreState *rstate, int64_t cluster_num,
++ int dirty)
++{
++ assert(rstate);
++ assert(rstate->bitmap);
++
++ unsigned long val, idx, bit;
++
++ idx = cluster_num / BITS_PER_LONG;
++
++ assert(rstate->bitmap_size > idx);
++
++ bit = cluster_num % BITS_PER_LONG;
++ val = rstate->bitmap[idx];
++ if (dirty) {
++ if (!(val & (1UL << bit))) {
++ val |= 1UL << bit;
++ }
++ } else {
++ if (val & (1UL << bit)) {
++ val &= ~(1UL << bit);
++ }
++ }
++ rstate->bitmap[idx] = val;
++}
++
++typedef struct VmaBlob {
++ uint32_t start;
++ uint32_t len;
++ void *data;
++} VmaBlob;
++
++static const VmaBlob *get_header_blob(VmaReader *vmar, uint32_t pos)
++{
++ assert(vmar);
++ assert(vmar->blob_hash);
++
++ return g_hash_table_lookup(vmar->blob_hash, &pos);
++}
++
++static const char *get_header_str(VmaReader *vmar, uint32_t pos)
++{
++ const VmaBlob *blob = get_header_blob(vmar, pos);
++ if (!blob) {
++ return NULL;
++ }
++ const char *res = (char *)blob->data;
++ if (res[blob->len-1] != '\0') {
++ return NULL;
++ }
++ return res;
++}
++
++static ssize_t
++safe_read(int fd, unsigned char *buf, size_t count)
++{
++ ssize_t n;
++
++ do {
++ n = read(fd, buf, count);
++ } while (n < 0 && errno == EINTR);
++
++ return n;
++}
++
++static ssize_t
++full_read(int fd, unsigned char *buf, size_t len)
++{
++ ssize_t n;
++ size_t total;
++
++ total = 0;
++
++ while (len > 0) {
++ n = safe_read(fd, buf, len);
++
++ if (n == 0) {
++ return total;
++ }
++
++ if (n <= 0) {
++ break;
++ }
++
++ buf += n;
++ total += n;
++ len -= n;
++ }
++
++ if (len) {
++ return -1;
++ }
++
++ return total;
++}
++
++void vma_reader_destroy(VmaReader *vmar)
++{
++ assert(vmar);
++
++ if (vmar->fd >= 0) {
++ close(vmar->fd);
++ }
++
++ if (vmar->cdata_list) {
++ g_list_free(vmar->cdata_list);
++ }
++
++ int i;
++ for (i = 1; i < 256; i++) {
++ if (vmar->rstate[i].bitmap) {
++ g_free(vmar->rstate[i].bitmap);
++ }
++ }
++
++ if (vmar->md5csum) {
++ g_checksum_free(vmar->md5csum);
++ }
++
++ if (vmar->blob_hash) {
++ g_hash_table_destroy(vmar->blob_hash);
++ }
++
++ if (vmar->head_data) {
++ g_free(vmar->head_data);
++ }
++
++ g_free(vmar);
++
++};
++
++static int vma_reader_read_head(VmaReader *vmar, Error **errp)
++{
++ assert(vmar);
++ assert(errp);
++ assert(*errp == NULL);
++
++ unsigned char md5sum[16];
++ int i;
++ int ret = 0;
++
++ vmar->head_data = g_malloc(sizeof(VmaHeader));
++
++ if (full_read(vmar->fd, vmar->head_data, sizeof(VmaHeader)) !=
++ sizeof(VmaHeader)) {
++ error_setg(errp, "can't read vma header - %s",
++ errno ? g_strerror(errno) : "got EOF");
++ return -1;
++ }
++
++ VmaHeader *h = (VmaHeader *)vmar->head_data;
++
++ if (h->magic != VMA_MAGIC) {
++ error_setg(errp, "not a vma file - wrong magic number");
++ return -1;
++ }
++
++ uint32_t header_size = GUINT32_FROM_BE(h->header_size);
++ int need = header_size - sizeof(VmaHeader);
++ if (need <= 0) {
++ error_setg(errp, "wrong vma header size %d", header_size);
++ return -1;
++ }
++
++ vmar->head_data = g_realloc(vmar->head_data, header_size);
++ h = (VmaHeader *)vmar->head_data;
++
++ if (full_read(vmar->fd, vmar->head_data + sizeof(VmaHeader), need) !=
++ need) {
++ error_setg(errp, "can't read vma header data - %s",
++ errno ? g_strerror(errno) : "got EOF");
++ return -1;
++ }
++
++ memcpy(md5sum, h->md5sum, 16);
++ memset(h->md5sum, 0, 16);
++
++ g_checksum_reset(vmar->md5csum);
++ g_checksum_update(vmar->md5csum, vmar->head_data, header_size);
++ gsize csize = 16;
++ g_checksum_get_digest(vmar->md5csum, (guint8 *)(h->md5sum), &csize);
++
++ if (memcmp(md5sum, h->md5sum, 16) != 0) {
++ error_setg(errp, "wrong vma header chechsum");
++ return -1;
++ }
++
++ /* we can modify header data after checksum verify */
++ h->header_size = header_size;
++
++ h->version = GUINT32_FROM_BE(h->version);
++ if (h->version != 1) {
++ error_setg(errp, "wrong vma version %d", h->version);
++ return -1;
++ }
++
++ h->ctime = GUINT64_FROM_BE(h->ctime);
++ h->blob_buffer_offset = GUINT32_FROM_BE(h->blob_buffer_offset);
++ h->blob_buffer_size = GUINT32_FROM_BE(h->blob_buffer_size);
++
++ uint32_t bstart = h->blob_buffer_offset + 1;
++ uint32_t bend = h->blob_buffer_offset + h->blob_buffer_size;
++
++ if (bstart <= sizeof(VmaHeader)) {
++ error_setg(errp, "wrong vma blob buffer offset %d",
++ h->blob_buffer_offset);
++ return -1;
++ }
++
++ if (bend > header_size) {
++ error_setg(errp, "wrong vma blob buffer size %d/%d",
++ h->blob_buffer_offset, h->blob_buffer_size);
++ return -1;
++ }
++
++ while ((bstart + 2) <= bend) {
++ uint32_t size = vmar->head_data[bstart] +
++ (vmar->head_data[bstart+1] << 8);
++ if ((bstart + size + 2) <= bend) {
++ VmaBlob *blob = g_new0(VmaBlob, 1);
++ blob->start = bstart - h->blob_buffer_offset;
++ blob->len = size;
++ blob->data = vmar->head_data + bstart + 2;
++ g_hash_table_insert(vmar->blob_hash, &blob->start, blob);
++ }
++ bstart += size + 2;
++ }
++
++
++ int count = 0;
++ for (i = 1; i < 256; i++) {
++ VmaDeviceInfoHeader *dih = &h->dev_info[i];
++ uint32_t devname_ptr = GUINT32_FROM_BE(dih->devname_ptr);
++ uint64_t size = GUINT64_FROM_BE(dih->size);
++ const char *devname = get_header_str(vmar, devname_ptr);
++
++ if (size && devname) {
++ count++;
++ vmar->devinfo[i].size = size;
++ vmar->devinfo[i].devname = devname;
++
++ if (strcmp(devname, "vmstate") == 0) {
++ vmar->vmstate_stream = i;
++ }
++ }
++ }
++
++ for (i = 0; i < VMA_MAX_CONFIGS; i++) {
++ uint32_t name_ptr = GUINT32_FROM_BE(h->config_names[i]);
++ uint32_t data_ptr = GUINT32_FROM_BE(h->config_data[i]);
++
++ if (!(name_ptr && data_ptr)) {
++ continue;
++ }
++ const char *name = get_header_str(vmar, name_ptr);
++ const VmaBlob *blob = get_header_blob(vmar, data_ptr);
++
++ if (!(name && blob)) {
++ error_setg(errp, "vma contains invalid data pointers");
++ return -1;
++ }
++
++ VmaConfigData *cdata = g_new0(VmaConfigData, 1);
++ cdata->name = name;
++ cdata->data = blob->data;
++ cdata->len = blob->len;
++
++ vmar->cdata_list = g_list_append(vmar->cdata_list, cdata);
++ }
++
++ return ret;
++};
++
++VmaReader *vma_reader_create(const char *filename, Error **errp)
++{
++ assert(filename);
++ assert(errp);
++
++ VmaReader *vmar = g_new0(VmaReader, 1);
++
++ if (strcmp(filename, "-") == 0) {
++ vmar->fd = dup(0);
++ } else {
++ vmar->fd = open(filename, O_RDONLY);
++ }
++
++ if (vmar->fd < 0) {
++ error_setg(errp, "can't open file %s - %s\n", filename,
++ g_strerror(errno));
++ goto err;
++ }
++
++ vmar->md5csum = g_checksum_new(G_CHECKSUM_MD5);
++ if (!vmar->md5csum) {
++ error_setg(errp, "can't allocate cmsum\n");
++ goto err;
++ }
++
++ vmar->blob_hash = g_hash_table_new_full(g_int32_hash, g_int32_equal,
++ NULL, g_free);
++
++ if (vma_reader_read_head(vmar, errp) < 0) {
++ goto err;
++ }
++
++ return vmar;
++
++err:
++ if (vmar) {
++ vma_reader_destroy(vmar);
++ }
++
++ return NULL;
++}
++
++VmaHeader *vma_reader_get_header(VmaReader *vmar)
++{
++ assert(vmar);
++ assert(vmar->head_data);
++
++ return (VmaHeader *)(vmar->head_data);
++}
++
++GList *vma_reader_get_config_data(VmaReader *vmar)
++{
++ assert(vmar);
++ assert(vmar->head_data);
++
++ return vmar->cdata_list;
++}
++
++VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id)
++{
++ assert(vmar);
++ assert(dev_id);
++
++ if (vmar->devinfo[dev_id].size && vmar->devinfo[dev_id].devname) {
++ return &vmar->devinfo[dev_id];
++ }
++
++ return NULL;
++}
++
++static void allocate_rstate(VmaReader *vmar, guint8 dev_id,
++ BlockBackend *target, bool write_zeroes)
++{
++ assert(vmar);
++ assert(dev_id);
++
++ vmar->rstate[dev_id].target = target;
++ vmar->rstate[dev_id].write_zeroes = write_zeroes;
++
++ int64_t size = vmar->devinfo[dev_id].size;
++
++ int64_t bitmap_size = (size/BDRV_SECTOR_SIZE) +
++ (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG - 1;
++ bitmap_size /= (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG;
++
++ vmar->rstate[dev_id].bitmap_size = bitmap_size;
++ vmar->rstate[dev_id].bitmap = g_new0(unsigned long, bitmap_size);
++
++ vmar->cluster_count += size/VMA_CLUSTER_SIZE;
++}
++
++int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockBackend *target,
++ bool write_zeroes, Error **errp)
++{
++ assert(vmar);
++ assert(target != NULL);
++ assert(dev_id);
++ assert(vmar->rstate[dev_id].target == NULL);
++
++ int64_t size = blk_getlength(target);
++ int64_t size_diff = size - vmar->devinfo[dev_id].size;
++
++ /* storage types can have different size restrictions, so it
++ * is not always possible to create an image with exact size.
++ * So we tolerate a size difference up to 4MB.
++ */
++ if ((size_diff < 0) || (size_diff > 4*1024*1024)) {
++ error_setg(errp, "vma_reader_register_bs for stream %s failed - "
++ "unexpected size %zd != %zd", vmar->devinfo[dev_id].devname,
++ size, vmar->devinfo[dev_id].size);
++ return -1;
++ }
++
++ allocate_rstate(vmar, dev_id, target, write_zeroes);
++
++ return 0;
++}
++
++static ssize_t safe_write(int fd, void *buf, size_t count)
++{
++ ssize_t n;
++
++ do {
++ n = write(fd, buf, count);
++ } while (n < 0 && errno == EINTR);
++
++ return n;
++}
++
++static size_t full_write(int fd, void *buf, size_t len)
++{
++ ssize_t n;
++ size_t total;
++
++ total = 0;
++
++ while (len > 0) {
++ n = safe_write(fd, buf, len);
++ if (n < 0) {
++ return n;
++ }
++ buf += n;
++ total += n;
++ len -= n;
++ }
++
++ if (len) {
++ /* incomplete write ? */
++ return -1;
++ }
++
++ return total;
++}
++
++static int restore_write_data(VmaReader *vmar, guint8 dev_id,
++ BlockBackend *target, int vmstate_fd,
++ unsigned char *buf, int64_t sector_num,
++ int nb_sectors, Error **errp)
++{
++ assert(vmar);
++
++ if (dev_id == vmar->vmstate_stream) {
++ if (vmstate_fd >= 0) {
++ int len = nb_sectors * BDRV_SECTOR_SIZE;
++ int res = full_write(vmstate_fd, buf, len);
++ if (res < 0) {
++ error_setg(errp, "write vmstate failed %d", res);
++ return -1;
++ }
++ }
++ } else {
++ int res = blk_pwrite(target, sector_num * BDRV_SECTOR_SIZE, buf, nb_sectors * BDRV_SECTOR_SIZE, 0);
++ if (res < 0) {
++ error_setg(errp, "blk_pwrite to %s failed (%d)",
++ bdrv_get_device_name(blk_bs(target)), res);
++ return -1;
++ }
++ }
++ return 0;
++}
++
++static int restore_extent(VmaReader *vmar, unsigned char *buf,
++ int extent_size, int vmstate_fd,
++ bool verbose, bool verify, Error **errp)
++{
++ assert(vmar);
++ assert(buf);
++
++ VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
++ int start = VMA_EXTENT_HEADER_SIZE;
++ int i;
++
++ for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
++ uint64_t block_info = GUINT64_FROM_BE(ehead->blockinfo[i]);
++ uint64_t cluster_num = block_info & 0xffffffff;
++ uint8_t dev_id = (block_info >> 32) & 0xff;
++ uint16_t mask = block_info >> (32+16);
++ int64_t max_sector;
++
++ if (!dev_id) {
++ continue;
++ }
++
++ VmaRestoreState *rstate = &vmar->rstate[dev_id];
++ BlockBackend *target = NULL;
++
++ if (dev_id != vmar->vmstate_stream) {
++ target = rstate->target;
++ if (!verify && !target) {
++ error_setg(errp, "got wrong dev id %d", dev_id);
++ return -1;
++ }
++
++ if (vma_reader_get_bitmap(rstate, cluster_num)) {
++ error_setg(errp, "found duplicated cluster %zd for stream %s",
++ cluster_num, vmar->devinfo[dev_id].devname);
++ return -1;
++ }
++ vma_reader_set_bitmap(rstate, cluster_num, 1);
++
++ max_sector = vmar->devinfo[dev_id].size/BDRV_SECTOR_SIZE;
++ } else {
++ max_sector = G_MAXINT64;
++ if (cluster_num != vmar->vmstate_clusters) {
++ error_setg(errp, "found out of order vmstate data");
++ return -1;
++ }
++ vmar->vmstate_clusters++;
++ }
++
++ vmar->clusters_read++;
++
++ if (verbose) {
++ time_t duration = time(NULL) - vmar->start_time;
++ int percent = (vmar->clusters_read*100)/vmar->cluster_count;
++ if (percent != vmar->clusters_read_per) {
++ printf("progress %d%% (read %zd bytes, duration %zd sec)\n",
++ percent, vmar->clusters_read*VMA_CLUSTER_SIZE,
++ duration);
++ fflush(stdout);
++ vmar->clusters_read_per = percent;
++ }
++ }
++
++ /* try to write whole clusters to speedup restore */
++ if (mask == 0xffff) {
++ if ((start + VMA_CLUSTER_SIZE) > extent_size) {
++ error_setg(errp, "short vma extent - too many blocks");
++ return -1;
++ }
++ int64_t sector_num = (cluster_num * VMA_CLUSTER_SIZE) /
++ BDRV_SECTOR_SIZE;
++ int64_t end_sector = sector_num +
++ VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE;
++
++ if (end_sector > max_sector) {
++ end_sector = max_sector;
++ }
++
++ if (end_sector <= sector_num) {
++ error_setg(errp, "got wrong block address - write beyond end");
++ return -1;
++ }
++
++ if (!verify) {
++ int nb_sectors = end_sector - sector_num;
++ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
++ buf + start, sector_num, nb_sectors,
++ errp) < 0) {
++ return -1;
++ }
++ }
++
++ start += VMA_CLUSTER_SIZE;
++ } else {
++ int j;
++ int bit = 1;
++
++ for (j = 0; j < 16; j++) {
++ int64_t sector_num = (cluster_num*VMA_CLUSTER_SIZE +
++ j*VMA_BLOCK_SIZE)/BDRV_SECTOR_SIZE;
++
++ int64_t end_sector = sector_num +
++ VMA_BLOCK_SIZE/BDRV_SECTOR_SIZE;
++ if (end_sector > max_sector) {
++ end_sector = max_sector;
++ }
++
++ if (mask & bit) {
++ if ((start + VMA_BLOCK_SIZE) > extent_size) {
++ error_setg(errp, "short vma extent - too many blocks");
++ return -1;
++ }
++
++ if (end_sector <= sector_num) {
++ error_setg(errp, "got wrong block address - "
++ "write beyond end");
++ return -1;
++ }
++
++ if (!verify) {
++ int nb_sectors = end_sector - sector_num;
++ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
++ buf + start, sector_num,
++ nb_sectors, errp) < 0) {
++ return -1;
++ }
++ }
++
++ start += VMA_BLOCK_SIZE;
++
++ } else {
++
++
++ if (end_sector > sector_num) {
++ /* Todo: use bdrv_co_write_zeroes (but that need to
++ * be run inside coroutine?)
++ */
++ int nb_sectors = end_sector - sector_num;
++ int zero_size = BDRV_SECTOR_SIZE*nb_sectors;
++ vmar->zero_cluster_data += zero_size;
++ if (mask != 0) {
++ vmar->partial_zero_cluster_data += zero_size;
++ }
++
++ if (rstate->write_zeroes && !verify) {
++ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
++ zero_vma_block, sector_num,
++ nb_sectors, errp) < 0) {
++ return -1;
++ }
++ }
++ }
++ }
++
++ bit = bit << 1;
++ }
++ }
++ }
++
++ if (start != extent_size) {
++ error_setg(errp, "vma extent error - missing blocks");
++ return -1;
++ }
++
++ return 0;
++}
++
++static int vma_reader_restore_full(VmaReader *vmar, int vmstate_fd,
++ bool verbose, bool verify,
++ Error **errp)
++{
++ assert(vmar);
++ assert(vmar->head_data);
++
++ int ret = 0;
++ unsigned char buf[VMA_MAX_EXTENT_SIZE];
++ int buf_pos = 0;
++ unsigned char md5sum[16];
++ VmaHeader *h = (VmaHeader *)vmar->head_data;
++
++ vmar->start_time = time(NULL);
++
++ while (1) {
++ int bytes = full_read(vmar->fd, buf + buf_pos, sizeof(buf) - buf_pos);
++ if (bytes < 0) {
++ error_setg(errp, "read failed - %s", g_strerror(errno));
++ return -1;
++ }
++
++ buf_pos += bytes;
++
++ if (!buf_pos) {
++ break; /* EOF */
++ }
++
++ if (buf_pos < VMA_EXTENT_HEADER_SIZE) {
++ error_setg(errp, "read short extent (%d bytes)", buf_pos);
++ return -1;
++ }
++
++ VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
++
++ /* extract md5sum */
++ memcpy(md5sum, ehead->md5sum, sizeof(ehead->md5sum));
++ memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
++
++ g_checksum_reset(vmar->md5csum);
++ g_checksum_update(vmar->md5csum, buf, VMA_EXTENT_HEADER_SIZE);
++ gsize csize = 16;
++ g_checksum_get_digest(vmar->md5csum, ehead->md5sum, &csize);
++
++ if (memcmp(md5sum, ehead->md5sum, 16) != 0) {
++ error_setg(errp, "wrong vma extent header chechsum");
++ return -1;
++ }
++
++ if (memcmp(h->uuid, ehead->uuid, sizeof(ehead->uuid)) != 0) {
++ error_setg(errp, "wrong vma extent uuid");
++ return -1;
++ }
++
++ if (ehead->magic != VMA_EXTENT_MAGIC || ehead->reserved1 != 0) {
++ error_setg(errp, "wrong vma extent header magic");
++ return -1;
++ }
++
++ int block_count = GUINT16_FROM_BE(ehead->block_count);
++ int extent_size = VMA_EXTENT_HEADER_SIZE + block_count*VMA_BLOCK_SIZE;
++
++ if (buf_pos < extent_size) {
++ error_setg(errp, "short vma extent (%d < %d)", buf_pos,
++ extent_size);
++ return -1;
++ }
++
++ if (restore_extent(vmar, buf, extent_size, vmstate_fd, verbose,
++ verify, errp) < 0) {
++ return -1;
++ }
++
++ if (buf_pos > extent_size) {
++ memmove(buf, buf + extent_size, buf_pos - extent_size);
++ buf_pos = buf_pos - extent_size;
++ } else {
++ buf_pos = 0;
++ }
++ }
++
++ bdrv_drain_all();
++
++ int i;
++ for (i = 1; i < 256; i++) {
++ VmaRestoreState *rstate = &vmar->rstate[i];
++ if (!rstate->target) {
++ continue;
++ }
++
++ if (blk_flush(rstate->target) < 0) {
++ error_setg(errp, "vma blk_flush %s failed",
++ vmar->devinfo[i].devname);
++ return -1;
++ }
++
++ if (vmar->devinfo[i].size &&
++ (strcmp(vmar->devinfo[i].devname, "vmstate") != 0)) {
++ assert(rstate->bitmap);
++
++ int64_t cluster_num, end;
++
++ end = (vmar->devinfo[i].size + VMA_CLUSTER_SIZE - 1) /
++ VMA_CLUSTER_SIZE;
++
++ for (cluster_num = 0; cluster_num < end; cluster_num++) {
++ if (!vma_reader_get_bitmap(rstate, cluster_num)) {
++ error_setg(errp, "detected missing cluster %zd "
++ "for stream %s", cluster_num,
++ vmar->devinfo[i].devname);
++ return -1;
++ }
++ }
++ }
++ }
++
++ if (verbose) {
++ if (vmar->clusters_read) {
++ printf("total bytes read %zd, sparse bytes %zd (%.3g%%)\n",
++ vmar->clusters_read*VMA_CLUSTER_SIZE,
++ vmar->zero_cluster_data,
++ (double)(100.0*vmar->zero_cluster_data)/
++ (vmar->clusters_read*VMA_CLUSTER_SIZE));
++
++ int64_t datasize = vmar->clusters_read*VMA_CLUSTER_SIZE-vmar->zero_cluster_data;
++ if (datasize) { // this does not make sense for empty files
++ printf("space reduction due to 4K zero blocks %.3g%%\n",
++ (double)(100.0*vmar->partial_zero_cluster_data) / datasize);
++ }
++ } else {
++ printf("vma archive contains no image data\n");
++ }
++ }
++ return ret;
++}
++
++int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
++ Error **errp)
++{
++ return vma_reader_restore_full(vmar, vmstate_fd, verbose, false, errp);
++}
++
++int vma_reader_verify(VmaReader *vmar, bool verbose, Error **errp)
++{
++ guint8 dev_id;
++
++ for (dev_id = 1; dev_id < 255; dev_id++) {
++ if (vma_reader_get_device_info(vmar, dev_id)) {
++ allocate_rstate(vmar, dev_id, NULL, false);
++ }
++ }
++
++ return vma_reader_restore_full(vmar, -1, verbose, true, errp);
++}
++
+diff --git a/vma-writer.c b/vma-writer.c
+new file mode 100644
+index 0000000000..f5d2c5d23c
+--- /dev/null
++++ b/vma-writer.c
+@@ -0,0 +1,790 @@
++/*
++ * VMA: Virtual Machine Archive
++ *
++ * Copyright (C) 2012 Proxmox Server Solutions
++ *
++ * Authors:
++ * Dietmar Maurer (dietmar@proxmox.com)
++ *
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++ * See the COPYING file in the top-level directory.
++ *
++ */
++
++#include "qemu/osdep.h"
++#include <glib.h>
++#include <uuid/uuid.h>
++
++#include "vma.h"
++#include "block/block.h"
++#include "monitor/monitor.h"
++#include "qemu/main-loop.h"
++#include "qemu/coroutine.h"
++#include "qemu/cutils.h"
++
++#define DEBUG_VMA 0
++
++#define DPRINTF(fmt, ...)\
++ do { if (DEBUG_VMA) { printf("vma: " fmt, ## __VA_ARGS__); } } while (0)
++
++#define WRITE_BUFFERS 5
++#define HEADER_CLUSTERS 8
++#define HEADERBUF_SIZE (VMA_CLUSTER_SIZE*HEADER_CLUSTERS)
++
++struct VmaWriter {
++ int fd;
++ FILE *cmd;
++ int status;
++ char errmsg[8192];
++ uuid_t uuid;
++ bool header_written;
++ bool closed;
++
++ /* we always write extents */
++ unsigned char *outbuf;
++ int outbuf_pos; /* in bytes */
++ int outbuf_count; /* in VMA_BLOCKS */
++ uint64_t outbuf_block_info[VMA_BLOCKS_PER_EXTENT];
++
++ unsigned char *headerbuf;
++
++ GChecksum *md5csum;
++ CoMutex flush_lock;
++ Coroutine *co_writer;
++
++ /* drive informations */
++ VmaStreamInfo stream_info[256];
++ guint stream_count;
++
++ guint8 vmstate_stream;
++ uint32_t vmstate_clusters;
++
++ /* header blob table */
++ char *header_blob_table;
++ uint32_t header_blob_table_size;
++ uint32_t header_blob_table_pos;
++
++ /* store for config blobs */
++ uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
++ uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
++ uint32_t config_count;
++};
++
++void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...)
++{
++ va_list ap;
++
++ if (vmaw->status < 0) {
++ return;
++ }
++
++ vmaw->status = -1;
++
++ va_start(ap, fmt);
++ g_vsnprintf(vmaw->errmsg, sizeof(vmaw->errmsg), fmt, ap);
++ va_end(ap);
++
++ DPRINTF("vma_writer_set_error: %s\n", vmaw->errmsg);
++}
++
++static uint32_t allocate_header_blob(VmaWriter *vmaw, const char *data,
++ size_t len)
++{
++ if (len > 65535) {
++ return 0;
++ }
++
++ if (!vmaw->header_blob_table ||
++ (vmaw->header_blob_table_size <
++ (vmaw->header_blob_table_pos + len + 2))) {
++ int newsize = vmaw->header_blob_table_size + ((len + 2 + 511)/512)*512;
++
++ vmaw->header_blob_table = g_realloc(vmaw->header_blob_table, newsize);
++ memset(vmaw->header_blob_table + vmaw->header_blob_table_size,
++ 0, newsize - vmaw->header_blob_table_size);
++ vmaw->header_blob_table_size = newsize;
++ }
++
++ uint32_t cpos = vmaw->header_blob_table_pos;
++ vmaw->header_blob_table[cpos] = len & 255;
++ vmaw->header_blob_table[cpos+1] = (len >> 8) & 255;
++ memcpy(vmaw->header_blob_table + cpos + 2, data, len);
++ vmaw->header_blob_table_pos += len + 2;
++ return cpos;
++}
++
++static uint32_t allocate_header_string(VmaWriter *vmaw, const char *str)
++{
++ assert(vmaw);
++
++ size_t len = strlen(str) + 1;
++
++ return allocate_header_blob(vmaw, str, len);
++}
++
++int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
++ gsize len)
++{
++ assert(vmaw);
++ assert(!vmaw->header_written);
++ assert(vmaw->config_count < VMA_MAX_CONFIGS);
++ assert(name);
++ assert(data);
++
++ gchar *basename = g_path_get_basename(name);
++ uint32_t name_ptr = allocate_header_string(vmaw, basename);
++ g_free(basename);
++
++ if (!name_ptr) {
++ return -1;
++ }
++
++ uint32_t data_ptr = allocate_header_blob(vmaw, data, len);
++ if (!data_ptr) {
++ return -1;
++ }
++
++ vmaw->config_names[vmaw->config_count] = name_ptr;
++ vmaw->config_data[vmaw->config_count] = data_ptr;
++
++ vmaw->config_count++;
++
++ return 0;
++}
++
++int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
++ size_t size)
++{
++ assert(vmaw);
++ assert(devname);
++ assert(!vmaw->status);
++
++ if (vmaw->header_written) {
++ vma_writer_set_error(vmaw, "vma_writer_register_stream: header "
++ "already written");
++ return -1;
++ }
++
++ guint n = vmaw->stream_count + 1;
++
++ /* we can have dev_ids form 1 to 255 (0 reserved)
++ * 255(-1) reseverd for safety
++ */
++ if (n > 254) {
++ vma_writer_set_error(vmaw, "vma_writer_register_stream: "
++ "too many drives");
++ return -1;
++ }
++
++ if (size <= 0) {
++ vma_writer_set_error(vmaw, "vma_writer_register_stream: "
++ "got strange size %zd", size);
++ return -1;
++ }
++
++ DPRINTF("vma_writer_register_stream %s %zu %d\n", devname, size, n);
++
++ vmaw->stream_info[n].devname = g_strdup(devname);
++ vmaw->stream_info[n].size = size;
++
++ vmaw->stream_info[n].cluster_count = (size + VMA_CLUSTER_SIZE - 1) /
++ VMA_CLUSTER_SIZE;
++
++ vmaw->stream_count = n;
++
++ if (strcmp(devname, "vmstate") == 0) {
++ vmaw->vmstate_stream = n;
++ }
++
++ return n;
++}
++
++static void coroutine_fn yield_until_fd_writable(int fd)
++{
++ assert(qemu_in_coroutine());
++ AioContext *ctx = qemu_get_current_aio_context();
++ aio_set_fd_handler(ctx, fd, false, NULL, (IOHandler *)qemu_coroutine_enter,
++ NULL, qemu_coroutine_self());
++ qemu_coroutine_yield();
++ aio_set_fd_handler(ctx, fd, false, NULL, NULL, NULL, NULL);
++}
++
++static ssize_t coroutine_fn
++vma_queue_write(VmaWriter *vmaw, const void *buf, size_t bytes)
++{
++ DPRINTF("vma_queue_write enter %zd\n", bytes);
++
++ assert(vmaw);
++ assert(buf);
++ assert(bytes <= VMA_MAX_EXTENT_SIZE);
++
++ size_t done = 0;
++ ssize_t ret;
++
++ assert(vmaw->co_writer == NULL);
++
++ vmaw->co_writer = qemu_coroutine_self();
++
++ while (done < bytes) {
++ if (vmaw->status < 0) {
++ DPRINTF("vma_queue_write detected canceled backup\n");
++ done = -1;
++ break;
++ }
++ yield_until_fd_writable(vmaw->fd);
++ ret = write(vmaw->fd, buf + done, bytes - done);
++ if (ret > 0) {
++ done += ret;
++ DPRINTF("vma_queue_write written %zd %zd\n", done, ret);
++ } else if (ret < 0) {
++ if (errno == EAGAIN || errno == EWOULDBLOCK) {
++ /* try again */
++ } else {
++ vma_writer_set_error(vmaw, "vma_queue_write: write error - %s",
++ g_strerror(errno));
++ done = -1; /* always return failure for partial writes */
++ break;
++ }
++ } else if (ret == 0) {
++ /* should not happen - simply try again */
++ }
++ }
++
++ vmaw->co_writer = NULL;
++
++ return (done == bytes) ? bytes : -1;
++}
++
++VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp)
++{
++ const char *p;
++
++ assert(sizeof(VmaHeader) == (4096 + 8192));
++ assert(G_STRUCT_OFFSET(VmaHeader, config_names) == 2044);
++ assert(G_STRUCT_OFFSET(VmaHeader, config_data) == 3068);
++ assert(G_STRUCT_OFFSET(VmaHeader, dev_info) == 4096);
++ assert(sizeof(VmaExtentHeader) == 512);
++
++ VmaWriter *vmaw = g_new0(VmaWriter, 1);
++ vmaw->fd = -1;
++
++ vmaw->md5csum = g_checksum_new(G_CHECKSUM_MD5);
++ if (!vmaw->md5csum) {
++ error_setg(errp, "can't allocate cmsum\n");
++ goto err;
++ }
++
++ if (strstart(filename, "exec:", &p)) {
++ vmaw->cmd = popen(p, "w");
++ if (vmaw->cmd == NULL) {
++ error_setg(errp, "can't popen command '%s' - %s\n", p,
++ g_strerror(errno));
++ goto err;
++ }
++ vmaw->fd = fileno(vmaw->cmd);
++
++ /* try to use O_NONBLOCK */
++ fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
++
++ } else {
++ struct stat st;
++ int oflags;
++ const char *tmp_id_str;
++
++ if ((stat(filename, &st) == 0) && S_ISFIFO(st.st_mode)) {
++ oflags = O_NONBLOCK|O_WRONLY;
++ vmaw->fd = qemu_open(filename, oflags, 0644);
++ } else if (strstart(filename, "/dev/fdset/", &tmp_id_str)) {
++ oflags = O_NONBLOCK|O_WRONLY;
++ vmaw->fd = qemu_open(filename, oflags, 0644);
++ } else if (strstart(filename, "/dev/fdname/", &tmp_id_str)) {
++ vmaw->fd = monitor_get_fd(cur_mon, tmp_id_str, errp);
++ if (vmaw->fd < 0) {
++ goto err;
++ }
++ /* try to use O_NONBLOCK */
++ fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
++ } else {
++ oflags = O_NONBLOCK|O_DIRECT|O_WRONLY|O_CREAT|O_EXCL;
++ vmaw->fd = qemu_open(filename, oflags, 0644);
++ }
++
++ if (vmaw->fd < 0) {
++ error_setg(errp, "can't open file %s - %s\n", filename,
++ g_strerror(errno));
++ goto err;
++ }
++ }
++
++ /* we use O_DIRECT, so we need to align IO buffers */
++
++ vmaw->outbuf = qemu_memalign(512, VMA_MAX_EXTENT_SIZE);
++ vmaw->headerbuf = qemu_memalign(512, HEADERBUF_SIZE);
++
++ vmaw->outbuf_count = 0;
++ vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
++
++ vmaw->header_blob_table_pos = 1; /* start at pos 1 */
++
++ qemu_co_mutex_init(&vmaw->flush_lock);
++
++ uuid_copy(vmaw->uuid, uuid);
++
++ return vmaw;
++
++err:
++ if (vmaw) {
++ if (vmaw->cmd) {
++ pclose(vmaw->cmd);
++ } else if (vmaw->fd >= 0) {
++ close(vmaw->fd);
++ }
++
++ if (vmaw->md5csum) {
++ g_checksum_free(vmaw->md5csum);
++ }
++
++ g_free(vmaw);
++ }
++
++ return NULL;
++}
++
++static int coroutine_fn vma_write_header(VmaWriter *vmaw)
++{
++ assert(vmaw);
++ unsigned char *buf = vmaw->headerbuf;
++ VmaHeader *head = (VmaHeader *)buf;
++
++ int i;
++
++ DPRINTF("VMA WRITE HEADER\n");
++
++ if (vmaw->status < 0) {
++ return vmaw->status;
++ }
++
++ memset(buf, 0, HEADERBUF_SIZE);
++
++ head->magic = VMA_MAGIC;
++ head->version = GUINT32_TO_BE(1); /* v1 */
++ memcpy(head->uuid, vmaw->uuid, 16);
++
++ time_t ctime = time(NULL);
++ head->ctime = GUINT64_TO_BE(ctime);
++
++ for (i = 0; i < VMA_MAX_CONFIGS; i++) {
++ head->config_names[i] = GUINT32_TO_BE(vmaw->config_names[i]);
++ head->config_data[i] = GUINT32_TO_BE(vmaw->config_data[i]);
++ }
++
++ /* 32 bytes per device (12 used currently) = 8192 bytes max */
++ for (i = 1; i <= 254; i++) {
++ VmaStreamInfo *si = &vmaw->stream_info[i];
++ if (si->size) {
++ assert(si->devname);
++ uint32_t devname_ptr = allocate_header_string(vmaw, si->devname);
++ if (!devname_ptr) {
++ return -1;
++ }
++ head->dev_info[i].devname_ptr = GUINT32_TO_BE(devname_ptr);
++ head->dev_info[i].size = GUINT64_TO_BE(si->size);
++ }
++ }
++
++ uint32_t header_size = sizeof(VmaHeader) + vmaw->header_blob_table_size;
++ head->header_size = GUINT32_TO_BE(header_size);
++
++ if (header_size > HEADERBUF_SIZE) {
++ return -1; /* just to be sure */
++ }
++
++ uint32_t blob_buffer_offset = sizeof(VmaHeader);
++ memcpy(buf + blob_buffer_offset, vmaw->header_blob_table,
++ vmaw->header_blob_table_size);
++ head->blob_buffer_offset = GUINT32_TO_BE(blob_buffer_offset);
++ head->blob_buffer_size = GUINT32_TO_BE(vmaw->header_blob_table_pos);
++
++ g_checksum_reset(vmaw->md5csum);
++ g_checksum_update(vmaw->md5csum, (const guchar *)buf, header_size);
++ gsize csize = 16;
++ g_checksum_get_digest(vmaw->md5csum, (guint8 *)(head->md5sum), &csize);
++
++ return vma_queue_write(vmaw, buf, header_size);
++}
++
++static int coroutine_fn vma_writer_flush(VmaWriter *vmaw)
++{
++ assert(vmaw);
++
++ int ret;
++ int i;
++
++ if (vmaw->status < 0) {
++ return vmaw->status;
++ }
++
++ if (!vmaw->header_written) {
++ vmaw->header_written = true;
++ ret = vma_write_header(vmaw);
++ if (ret < 0) {
++ vma_writer_set_error(vmaw, "vma_writer_flush: write header failed");
++ return ret;
++ }
++ }
++
++ DPRINTF("VMA WRITE FLUSH %d %d\n", vmaw->outbuf_count, vmaw->outbuf_pos);
++
++
++ VmaExtentHeader *ehead = (VmaExtentHeader *)vmaw->outbuf;
++
++ ehead->magic = VMA_EXTENT_MAGIC;
++ ehead->reserved1 = 0;
++
++ for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
++ ehead->blockinfo[i] = GUINT64_TO_BE(vmaw->outbuf_block_info[i]);
++ }
++
++ guint16 block_count = (vmaw->outbuf_pos - VMA_EXTENT_HEADER_SIZE) /
++ VMA_BLOCK_SIZE;
++
++ ehead->block_count = GUINT16_TO_BE(block_count);
++
++ memcpy(ehead->uuid, vmaw->uuid, sizeof(ehead->uuid));
++ memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
++
++ g_checksum_reset(vmaw->md5csum);
++ g_checksum_update(vmaw->md5csum, vmaw->outbuf, VMA_EXTENT_HEADER_SIZE);
++ gsize csize = 16;
++ g_checksum_get_digest(vmaw->md5csum, ehead->md5sum, &csize);
++
++ int bytes = vmaw->outbuf_pos;
++ ret = vma_queue_write(vmaw, vmaw->outbuf, bytes);
++ if (ret != bytes) {
++ vma_writer_set_error(vmaw, "vma_writer_flush: failed write");
++ }
++
++ vmaw->outbuf_count = 0;
++ vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
++
++ for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
++ vmaw->outbuf_block_info[i] = 0;
++ }
++
++ return vmaw->status;
++}
++
++static int vma_count_open_streams(VmaWriter *vmaw)
++{
++ g_assert(vmaw != NULL);
++
++ int i;
++ int open_drives = 0;
++ for (i = 0; i <= 255; i++) {
++ if (vmaw->stream_info[i].size && !vmaw->stream_info[i].finished) {
++ open_drives++;
++ }
++ }
++
++ return open_drives;
++}
++
++
++/**
++ * You need to call this if the vma archive does not contain
++ * any data stream.
++ */
++int coroutine_fn
++vma_writer_flush_output(VmaWriter *vmaw)
++{
++ qemu_co_mutex_lock(&vmaw->flush_lock);
++ int ret = vma_writer_flush(vmaw);
++ qemu_co_mutex_unlock(&vmaw->flush_lock);
++ if (ret < 0) {
++ vma_writer_set_error(vmaw, "vma_writer_flush_header failed");
++ }
++ return ret;
++}
++
++/**
++ * all jobs should call this when there is no more data
++ * Returns: number of remaining stream (0 ==> finished)
++ */
++int coroutine_fn
++vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id)
++{
++ g_assert(vmaw != NULL);
++
++ DPRINTF("vma_writer_set_status %d\n", dev_id);
++ if (!vmaw->stream_info[dev_id].size) {
++ vma_writer_set_error(vmaw, "vma_writer_close_stream: "
++ "no such stream %d", dev_id);
++ return -1;
++ }
++ if (vmaw->stream_info[dev_id].finished) {
++ vma_writer_set_error(vmaw, "vma_writer_close_stream: "
++ "stream already closed %d", dev_id);
++ return -1;
++ }
++
++ vmaw->stream_info[dev_id].finished = true;
++
++ int open_drives = vma_count_open_streams(vmaw);
++
++ if (open_drives <= 0) {
++ DPRINTF("vma_writer_set_status all drives completed\n");
++ vma_writer_flush_output(vmaw);
++ }
++
++ return open_drives;
++}
++
++int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status)
++{
++ int i;
++
++ g_assert(vmaw != NULL);
++
++ if (status) {
++ status->status = vmaw->status;
++ g_strlcpy(status->errmsg, vmaw->errmsg, sizeof(status->errmsg));
++ for (i = 0; i <= 255; i++) {
++ status->stream_info[i] = vmaw->stream_info[i];
++ }
++
++ uuid_unparse_lower(vmaw->uuid, status->uuid_str);
++ }
++
++ status->closed = vmaw->closed;
++
++ return vmaw->status;
++}
++
++static int vma_writer_get_buffer(VmaWriter *vmaw)
++{
++ int ret = 0;
++
++ qemu_co_mutex_lock(&vmaw->flush_lock);
++
++ /* wait until buffer is available */
++ while (vmaw->outbuf_count >= (VMA_BLOCKS_PER_EXTENT - 1)) {
++ ret = vma_writer_flush(vmaw);
++ if (ret < 0) {
++ vma_writer_set_error(vmaw, "vma_writer_get_buffer: flush failed");
++ break;
++ }
++ }
++
++ qemu_co_mutex_unlock(&vmaw->flush_lock);
++
++ return ret;
++}
++
++
++int64_t coroutine_fn
++vma_writer_write(VmaWriter *vmaw, uint8_t dev_id, int64_t cluster_num,
++ const unsigned char *buf, size_t *zero_bytes)
++{
++ g_assert(vmaw != NULL);
++ g_assert(zero_bytes != NULL);
++
++ *zero_bytes = 0;
++
++ if (vmaw->status < 0) {
++ return vmaw->status;
++ }
++
++ if (!dev_id || !vmaw->stream_info[dev_id].size) {
++ vma_writer_set_error(vmaw, "vma_writer_write: "
++ "no such stream %d", dev_id);
++ return -1;
++ }
++
++ if (vmaw->stream_info[dev_id].finished) {
++ vma_writer_set_error(vmaw, "vma_writer_write: "
++ "stream already closed %d", dev_id);
++ return -1;
++ }
++
++
++ if (cluster_num >= (((uint64_t)1)<<32)) {
++ vma_writer_set_error(vmaw, "vma_writer_write: "
++ "cluster number out of range");
++ return -1;
++ }
++
++ if (dev_id == vmaw->vmstate_stream) {
++ if (cluster_num != vmaw->vmstate_clusters) {
++ vma_writer_set_error(vmaw, "vma_writer_write: "
++ "non sequential vmstate write");
++ }
++ vmaw->vmstate_clusters++;
++ } else if (cluster_num >= vmaw->stream_info[dev_id].cluster_count) {
++ vma_writer_set_error(vmaw, "vma_writer_write: cluster number too big");
++ return -1;
++ }
++
++ /* wait until buffer is available */
++ if (vma_writer_get_buffer(vmaw) < 0) {
++ vma_writer_set_error(vmaw, "vma_writer_write: "
++ "vma_writer_get_buffer failed");
++ return -1;
++ }
++
++ DPRINTF("VMA WRITE %d %zd\n", dev_id, cluster_num);
++
++ uint64_t dev_size = vmaw->stream_info[dev_id].size;
++ uint16_t mask = 0;
++
++ if (buf) {
++ int i;
++ int bit = 1;
++ uint64_t byte_offset = cluster_num * VMA_CLUSTER_SIZE;
++ for (i = 0; i < 16; i++) {
++ const unsigned char *vmablock = buf + (i*VMA_BLOCK_SIZE);
++
++ // Note: If the source is not 64k-aligned, we might reach 4k blocks
++ // after the end of the device. Always mark these as zero in the
++ // mask, so the restore handles them correctly.
++ if (byte_offset < dev_size &&
++ !buffer_is_zero(vmablock, VMA_BLOCK_SIZE))
++ {
++ mask |= bit;
++ memcpy(vmaw->outbuf + vmaw->outbuf_pos, vmablock,
++ VMA_BLOCK_SIZE);
++
++ // prevent memory leakage on unaligned last block
++ if (byte_offset + VMA_BLOCK_SIZE > dev_size) {
++ uint64_t real_data_in_block = dev_size - byte_offset;
++ memset(vmaw->outbuf + vmaw->outbuf_pos + real_data_in_block,
++ 0, VMA_BLOCK_SIZE - real_data_in_block);
++ }
++
++ vmaw->outbuf_pos += VMA_BLOCK_SIZE;
++ } else {
++ DPRINTF("VMA WRITE %zd ZERO BLOCK %d\n", cluster_num, i);
++ vmaw->stream_info[dev_id].zero_bytes += VMA_BLOCK_SIZE;
++ *zero_bytes += VMA_BLOCK_SIZE;
++ }
++
++ byte_offset += VMA_BLOCK_SIZE;
++ bit = bit << 1;
++ }
++ } else {
++ DPRINTF("VMA WRITE %zd ZERO CLUSTER\n", cluster_num);
++ vmaw->stream_info[dev_id].zero_bytes += VMA_CLUSTER_SIZE;
++ *zero_bytes += VMA_CLUSTER_SIZE;
++ }
++
++ uint64_t block_info = ((uint64_t)mask) << (32+16);
++ block_info |= ((uint64_t)dev_id) << 32;
++ block_info |= (cluster_num & 0xffffffff);
++ vmaw->outbuf_block_info[vmaw->outbuf_count] = block_info;
++
++ DPRINTF("VMA WRITE MASK %zd %zx\n", cluster_num, block_info);
++
++ vmaw->outbuf_count++;
++
++ /** NOTE: We allways write whole clusters, but we correctly set
++ * transferred bytes. So transferred == size when when everything
++ * went OK.
++ */
++ size_t transferred = VMA_CLUSTER_SIZE;
++
++ if (dev_id != vmaw->vmstate_stream) {
++ uint64_t last = (cluster_num + 1) * VMA_CLUSTER_SIZE;
++ if (last > dev_size) {
++ uint64_t diff = last - dev_size;
++ if (diff >= VMA_CLUSTER_SIZE) {
++ vma_writer_set_error(vmaw, "vma_writer_write: "
++ "read after last cluster");
++ return -1;
++ }
++ transferred -= diff;
++ }
++ }
++
++ vmaw->stream_info[dev_id].transferred += transferred;
++
++ return transferred;
++}
++
++void vma_writer_error_propagate(VmaWriter *vmaw, Error **errp)
++{
++ if (vmaw->status < 0 && *errp == NULL) {
++ error_setg(errp, "%s", vmaw->errmsg);
++ }
++}
++
++int vma_writer_close(VmaWriter *vmaw, Error **errp)
++{
++ g_assert(vmaw != NULL);
++
++ int i;
++
++ qemu_co_mutex_lock(&vmaw->flush_lock); // wait for pending writes
++
++ assert(vmaw->co_writer == NULL);
++
++ if (vmaw->cmd) {
++ if (pclose(vmaw->cmd) < 0) {
++ vma_writer_set_error(vmaw, "vma_writer_close: "
++ "pclose failed - %s", g_strerror(errno));
++ }
++ } else {
++ if (close(vmaw->fd) < 0) {
++ vma_writer_set_error(vmaw, "vma_writer_close: "
++ "close failed - %s", g_strerror(errno));
++ }
++ }
++
++ for (i = 0; i <= 255; i++) {
++ VmaStreamInfo *si = &vmaw->stream_info[i];
++ if (si->size) {
++ if (!si->finished) {
++ vma_writer_set_error(vmaw, "vma_writer_close: "
++ "detected open stream '%s'", si->devname);
++ } else if ((si->transferred != si->size) &&
++ (i != vmaw->vmstate_stream)) {
++ vma_writer_set_error(vmaw, "vma_writer_close: "
++ "incomplete stream '%s' (%zd != %zd)",
++ si->devname, si->transferred, si->size);
++ }
++ }
++ }
++
++ for (i = 0; i <= 255; i++) {
++ vmaw->stream_info[i].finished = 1; /* mark as closed */
++ }
++
++ vmaw->closed = 1;
++
++ if (vmaw->status < 0 && *errp == NULL) {
++ error_setg(errp, "%s", vmaw->errmsg);
++ }
++
++ qemu_co_mutex_unlock(&vmaw->flush_lock);
++
++ return vmaw->status;
++}
++
++void vma_writer_destroy(VmaWriter *vmaw)
++{
++ assert(vmaw);
++
++ int i;
++
++ for (i = 0; i <= 255; i++) {
++ if (vmaw->stream_info[i].devname) {
++ g_free(vmaw->stream_info[i].devname);
++ }
++ }
++
++ if (vmaw->md5csum) {
++ g_checksum_free(vmaw->md5csum);
++ }
++
++ qemu_vfree(vmaw->headerbuf);
++ qemu_vfree(vmaw->outbuf);
++ g_free(vmaw);
++}
+diff --git a/vma.c b/vma.c
+new file mode 100644
+index 0000000000..2eea2fc281
+--- /dev/null
++++ b/vma.c
+@@ -0,0 +1,839 @@
++/*
++ * VMA: Virtual Machine Archive
++ *
++ * Copyright (C) 2012-2013 Proxmox Server Solutions
++ *
++ * Authors:
++ * Dietmar Maurer (dietmar@proxmox.com)
++ *
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++ * See the COPYING file in the top-level directory.
++ *
++ */
++
++#include "qemu/osdep.h"
++#include <glib.h>
++
++#include "vma.h"
++#include "qemu-common.h"
++#include "qemu/module.h"
++#include "qemu/error-report.h"
++#include "qemu/main-loop.h"
++#include "qemu/cutils.h"
++#include "qapi/qmp/qdict.h"
++#include "sysemu/block-backend.h"
++
++static void help(void)
++{
++ const char *help_msg =
++ "usage: vma command [command options]\n"
++ "\n"
++ "vma list <filename>\n"
++ "vma config <filename> [-c config]\n"
++ "vma create <filename> [-c config] pathname ...\n"
++ "vma extract <filename> [-r <fifo>] <targetdir>\n"
++ "vma verify <filename> [-v]\n"
++ ;
++
++ printf("%s", help_msg);
++ exit(1);
++}
++
++static const char *extract_devname(const char *path, char **devname, int index)
++{
++ assert(path);
++
++ const char *sep = strchr(path, '=');
++
++ if (sep) {
++ *devname = g_strndup(path, sep - path);
++ path = sep + 1;
++ } else {
++ if (index >= 0) {
++ *devname = g_strdup_printf("disk%d", index);
++ } else {
++ *devname = NULL;
++ }
++ }
++
++ return path;
++}
++
++static void print_content(VmaReader *vmar)
++{
++ assert(vmar);
++
++ VmaHeader *head = vma_reader_get_header(vmar);
++
++ GList *l = vma_reader_get_config_data(vmar);
++ while (l && l->data) {
++ VmaConfigData *cdata = (VmaConfigData *)l->data;
++ l = g_list_next(l);
++ printf("CFG: size: %d name: %s\n", cdata->len, cdata->name);
++ }
++
++ int i;
++ VmaDeviceInfo *di;
++ for (i = 1; i < 255; i++) {
++ di = vma_reader_get_device_info(vmar, i);
++ if (di) {
++ if (strcmp(di->devname, "vmstate") == 0) {
++ printf("VMSTATE: dev_id=%d memory: %zd\n", i, di->size);
++ } else {
++ printf("DEV: dev_id=%d size: %zd devname: %s\n",
++ i, di->size, di->devname);
++ }
++ }
++ }
++ /* ctime is the last entry we print */
++ printf("CTIME: %s", ctime(&head->ctime));
++ fflush(stdout);
++}
++
++static int list_content(int argc, char **argv)
++{
++ int c, ret = 0;
++ const char *filename;
++
++ for (;;) {
++ c = getopt(argc, argv, "h");
++ if (c == -1) {
++ break;
++ }
++ switch (c) {
++ case '?':
++ case 'h':
++ help();
++ break;
++ default:
++ g_assert_not_reached();
++ }
++ }
++
++ /* Get the filename */
++ if ((optind + 1) != argc) {
++ help();
++ }
++ filename = argv[optind++];
++
++ Error *errp = NULL;
++ VmaReader *vmar = vma_reader_create(filename, &errp);
++
++ if (!vmar) {
++ g_error("%s", error_get_pretty(errp));
++ }
++
++ print_content(vmar);
++
++ vma_reader_destroy(vmar);
++
++ return ret;
++}
++
++typedef struct RestoreMap {
++ char *devname;
++ char *path;
++ char *format;
++ uint64_t throttling_bps;
++ char *throttling_group;
++ char *cache;
++ bool write_zero;
++} RestoreMap;
++
++static bool try_parse_option(char **line, const char *optname, char **out, const char *inbuf) {
++ size_t optlen = strlen(optname);
++ if (strncmp(*line, optname, optlen) != 0 || (*line)[optlen] != '=') {
++ return false;
++ }
++ if (*out) {
++ g_error("read map failed - duplicate value for option '%s'", optname);
++ }
++ char *value = (*line) + optlen + 1; /* including a '=' */
++ char *colon = strchr(value, ':');
++ if (!colon) {
++ g_error("read map failed - option '%s' not terminated ('%s')",
++ optname, inbuf);
++ }
++ *line = colon+1;
++ *out = g_strndup(value, colon - value);
++ return true;
++}
++
++static uint64_t verify_u64(const char *text) {
++ uint64_t value;
++ const char *endptr = NULL;
++ if (qemu_strtou64(text, &endptr, 0, &value) != 0 || !endptr || *endptr) {
++ g_error("read map failed - not a number: %s", text);
++ }
++ return value;
++}
++
++static int extract_content(int argc, char **argv)
++{
++ int c, ret = 0;
++ int verbose = 0;
++ const char *filename;
++ const char *dirname;
++ const char *readmap = NULL;
++
++ for (;;) {
++ c = getopt(argc, argv, "hvr:");
++ if (c == -1) {
++ break;
++ }
++ switch (c) {
++ case '?':
++ case 'h':
++ help();
++ break;
++ case 'r':
++ readmap = optarg;
++ break;
++ case 'v':
++ verbose = 1;
++ break;
++ default:
++ help();
++ }
++ }
++
++ /* Get the filename */
++ if ((optind + 2) != argc) {
++ help();
++ }
++ filename = argv[optind++];
++ dirname = argv[optind++];
++
++ Error *errp = NULL;
++ VmaReader *vmar = vma_reader_create(filename, &errp);
++
++ if (!vmar) {
++ g_error("%s", error_get_pretty(errp));
++ }
++
++ if (mkdir(dirname, 0777) < 0) {
++ g_error("unable to create target directory %s - %s",
++ dirname, g_strerror(errno));
++ }
++
++ GList *l = vma_reader_get_config_data(vmar);
++ while (l && l->data) {
++ VmaConfigData *cdata = (VmaConfigData *)l->data;
++ l = g_list_next(l);
++ char *cfgfn = g_strdup_printf("%s/%s", dirname, cdata->name);
++ GError *err = NULL;
++ if (!g_file_set_contents(cfgfn, (gchar *)cdata->data, cdata->len,
++ &err)) {
++ g_error("unable to write file: %s", err->message);
++ }
++ }
++
++ GHashTable *devmap = g_hash_table_new(g_str_hash, g_str_equal);
++
++ if (readmap) {
++ print_content(vmar);
++
++ FILE *map = fopen(readmap, "r");
++ if (!map) {
++ g_error("unable to open fifo %s - %s", readmap, g_strerror(errno));
++ }
++
++ while (1) {
++ char inbuf[8192];
++ char *line = fgets(inbuf, sizeof(inbuf), map);
++ char *format = NULL;
++ char *bps = NULL;
++ char *group = NULL;
++ char *cache = NULL;
++ if (!line || line[0] == '\0' || !strcmp(line, "done\n")) {
++ break;
++ }
++ int len = strlen(line);
++ if (line[len - 1] == '\n') {
++ line[len - 1] = '\0';
++ if (len == 1) {
++ break;
++ }
++ }
++
++ while (1) {
++ if (!try_parse_option(&line, "format", &format, inbuf) &&
++ !try_parse_option(&line, "throttling.bps", &bps, inbuf) &&
++ !try_parse_option(&line, "throttling.group", &group, inbuf) &&
++ !try_parse_option(&line, "cache", &cache, inbuf))
++ {
++ break;
++ }
++ }
++
++ uint64_t bps_value = 0;
++ if (bps) {
++ bps_value = verify_u64(bps);
++ g_free(bps);
++ }
++
++ const char *path;
++ bool write_zero;
++ if (line[0] == '0' && line[1] == ':') {
++ path = line + 2;
++ write_zero = false;
++ } else if (line[0] == '1' && line[1] == ':') {
++ path = line + 2;
++ write_zero = true;
++ } else {
++ g_error("read map failed - parse error ('%s')", inbuf);
++ }
++
++ char *devname = NULL;
++ path = extract_devname(path, &devname, -1);
++ if (!devname) {
++ g_error("read map failed - no dev name specified ('%s')",
++ inbuf);
++ }
++
++ RestoreMap *map = g_new0(RestoreMap, 1);
++ map->devname = g_strdup(devname);
++ map->path = g_strdup(path);
++ map->format = format;
++ map->throttling_bps = bps_value;
++ map->throttling_group = group;
++ map->cache = cache;
++ map->write_zero = write_zero;
++
++ g_hash_table_insert(devmap, map->devname, map);
++
++ };
++ }
++
++ int i;
++ int vmstate_fd = -1;
++ guint8 vmstate_stream = 0;
++
++ BlockBackend *blk = NULL;
++
++ for (i = 1; i < 255; i++) {
++ VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
++ if (di && (strcmp(di->devname, "vmstate") == 0)) {
++ vmstate_stream = i;
++ char *statefn = g_strdup_printf("%s/vmstate.bin", dirname);
++ vmstate_fd = open(statefn, O_WRONLY|O_CREAT|O_EXCL, 0644);
++ if (vmstate_fd < 0) {
++ g_error("create vmstate file '%s' failed - %s", statefn,
++ g_strerror(errno));
++ }
++ g_free(statefn);
++ } else if (di) {
++ char *devfn = NULL;
++ const char *format = NULL;
++ uint64_t throttling_bps = 0;
++ const char *throttling_group = NULL;
++ const char *cache = NULL;
++ int flags = BDRV_O_RDWR;
++ bool write_zero = true;
++
++ if (readmap) {
++ RestoreMap *map;
++ map = (RestoreMap *)g_hash_table_lookup(devmap, di->devname);
++ if (map == NULL) {
++ g_error("no device name mapping for %s", di->devname);
++ }
++ devfn = map->path;
++ format = map->format;
++ throttling_bps = map->throttling_bps;
++ throttling_group = map->throttling_group;
++ cache = map->cache;
++ write_zero = map->write_zero;
++ } else {
++ devfn = g_strdup_printf("%s/tmp-disk-%s.raw",
++ dirname, di->devname);
++ printf("DEVINFO %s %zd\n", devfn, di->size);
++
++ bdrv_img_create(devfn, "raw", NULL, NULL, NULL, di->size,
++ flags, true, &errp);
++ if (errp) {
++ g_error("can't create file %s: %s", devfn,
++ error_get_pretty(errp));
++ }
++
++ /* Note: we created an empty file above, so there is no
++ * need to write zeroes (so we generate a sparse file)
++ */
++ write_zero = false;
++ }
++
++ size_t devlen = strlen(devfn);
++ QDict *options = NULL;
++ bool writethrough;
++ if (format) {
++ /* explicit format from commandline */
++ options = qdict_new();
++ qdict_put_str(options, "driver", format);
++ } else if ((devlen > 4 && strcmp(devfn+devlen-4, ".raw") == 0) ||
++ strncmp(devfn, "/dev/", 5) == 0)
++ {
++ /* This part is now deprecated for PVE as well (just as qemu
++ * deprecated not specifying an explicit raw format, too.
++ */
++ /* explicit raw format */
++ options = qdict_new();
++ qdict_put_str(options, "driver", "raw");
++ }
++ if (cache && bdrv_parse_cache_mode(cache, &flags, &writethrough)) {
++ g_error("invalid cache option: %s\n", cache);
++ }
++
++ if (errp || !(blk = blk_new_open(devfn, NULL, options, flags, &errp))) {
++ g_error("can't open file %s - %s", devfn,
++ error_get_pretty(errp));
++ }
++
++ if (cache) {
++ blk_set_enable_write_cache(blk, !writethrough);
++ }
++
++ if (throttling_group) {
++ blk_io_limits_enable(blk, throttling_group);
++ }
++
++ if (throttling_bps) {
++ if (!throttling_group) {
++ blk_io_limits_enable(blk, devfn);
++ }
++
++ ThrottleConfig cfg;
++ throttle_config_init(&cfg);
++ cfg.buckets[THROTTLE_BPS_WRITE].avg = throttling_bps;
++ Error *err = NULL;
++ if (!throttle_is_valid(&cfg, &err)) {
++ error_report_err(err);
++ g_error("failed to apply throttling");
++ }
++ blk_set_io_limits(blk, &cfg);
++ }
++
++ if (vma_reader_register_bs(vmar, i, blk, write_zero, &errp) < 0) {
++ g_error("%s", error_get_pretty(errp));
++ }
++
++ if (!readmap) {
++ g_free(devfn);
++ }
++ }
++ }
++
++ if (vma_reader_restore(vmar, vmstate_fd, verbose, &errp) < 0) {
++ g_error("restore failed - %s", error_get_pretty(errp));
++ }
++
++ if (!readmap) {
++ for (i = 1; i < 255; i++) {
++ VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
++ if (di && (i != vmstate_stream)) {
++ char *tmpfn = g_strdup_printf("%s/tmp-disk-%s.raw",
++ dirname, di->devname);
++ char *fn = g_strdup_printf("%s/disk-%s.raw",
++ dirname, di->devname);
++ if (rename(tmpfn, fn) != 0) {
++ g_error("rename %s to %s failed - %s",
++ tmpfn, fn, g_strerror(errno));
++ }
++ }
++ }
++ }
++
++ vma_reader_destroy(vmar);
++
++ blk_unref(blk);
++
++ bdrv_close_all();
++
++ return ret;
++}
++
++static int verify_content(int argc, char **argv)
++{
++ int c, ret = 0;
++ int verbose = 0;
++ const char *filename;
++
++ for (;;) {
++ c = getopt(argc, argv, "hv");
++ if (c == -1) {
++ break;
++ }
++ switch (c) {
++ case '?':
++ case 'h':
++ help();
++ break;
++ case 'v':
++ verbose = 1;
++ break;
++ default:
++ help();
++ }
++ }
++
++ /* Get the filename */
++ if ((optind + 1) != argc) {
++ help();
++ }
++ filename = argv[optind++];
++
++ Error *errp = NULL;
++ VmaReader *vmar = vma_reader_create(filename, &errp);
++
++ if (!vmar) {
++ g_error("%s", error_get_pretty(errp));
++ }
++
++ if (verbose) {
++ print_content(vmar);
++ }
++
++ if (vma_reader_verify(vmar, verbose, &errp) < 0) {
++ g_error("verify failed - %s", error_get_pretty(errp));
++ }
++
++ vma_reader_destroy(vmar);
++
++ bdrv_close_all();
++
++ return ret;
++}
++
++typedef struct BackupJob {
++ BlockBackend *target;
++ int64_t len;
++ VmaWriter *vmaw;
++ uint8_t dev_id;
++} BackupJob;
++
++#define BACKUP_SECTORS_PER_CLUSTER (VMA_CLUSTER_SIZE / BDRV_SECTOR_SIZE)
++
++static void coroutine_fn backup_run_empty(void *opaque)
++{
++ VmaWriter *vmaw = (VmaWriter *)opaque;
++
++ vma_writer_flush_output(vmaw);
++
++ Error *err = NULL;
++ if (vma_writer_close(vmaw, &err) != 0) {
++ g_warning("vma_writer_close failed %s", error_get_pretty(err));
++ }
++}
++
++static void coroutine_fn backup_run(void *opaque)
++{
++ BackupJob *job = (BackupJob *)opaque;
++ struct iovec iov;
++ QEMUIOVector qiov;
++
++ int64_t start, end;
++ int ret = 0;
++
++ unsigned char *buf = blk_blockalign(job->target, VMA_CLUSTER_SIZE);
++
++ start = 0;
++ end = DIV_ROUND_UP(job->len / BDRV_SECTOR_SIZE,
++ BACKUP_SECTORS_PER_CLUSTER);
++
++ for (; start < end; start++) {
++ iov.iov_base = buf;
++ iov.iov_len = VMA_CLUSTER_SIZE;
++ qemu_iovec_init_external(&qiov, &iov, 1);
++
++ ret = blk_co_preadv(job->target, start * VMA_CLUSTER_SIZE,
++ VMA_CLUSTER_SIZE, &qiov, 0);
++ if (ret < 0) {
++ vma_writer_set_error(job->vmaw, "read error", -1);
++ goto out;
++ }
++
++ size_t zb = 0;
++ if (vma_writer_write(job->vmaw, job->dev_id, start, buf, &zb) < 0) {
++ vma_writer_set_error(job->vmaw, "backup_dump_cb vma_writer_write failed", -1);
++ goto out;
++ }
++ }
++
++
++out:
++ if (vma_writer_close_stream(job->vmaw, job->dev_id) <= 0) {
++ Error *err = NULL;
++ if (vma_writer_close(job->vmaw, &err) != 0) {
++ g_warning("vma_writer_close failed %s", error_get_pretty(err));
++ }
++ }
++ qemu_vfree(buf);
++}
++
++static int create_archive(int argc, char **argv)
++{
++ int i, c;
++ int verbose = 0;
++ const char *archivename;
++ GList *config_files = NULL;
++
++ for (;;) {
++ c = getopt(argc, argv, "hvc:");
++ if (c == -1) {
++ break;
++ }
++ switch (c) {
++ case '?':
++ case 'h':
++ help();
++ break;
++ case 'c':
++ config_files = g_list_append(config_files, optarg);
++ break;
++ case 'v':
++ verbose = 1;
++ break;
++ default:
++ g_assert_not_reached();
++ }
++ }
++
++
++ /* make sure we an archive name */
++ if ((optind + 1) > argc) {
++ help();
++ }
++
++ archivename = argv[optind++];
++
++ uuid_t uuid;
++ uuid_generate(uuid);
++
++ Error *local_err = NULL;
++ VmaWriter *vmaw = vma_writer_create(archivename, uuid, &local_err);
++
++ if (vmaw == NULL) {
++ g_error("%s", error_get_pretty(local_err));
++ }
++
++ GList *l = config_files;
++ while (l && l->data) {
++ char *name = l->data;
++ char *cdata = NULL;
++ gsize clen = 0;
++ GError *err = NULL;
++ if (!g_file_get_contents(name, &cdata, &clen, &err)) {
++ unlink(archivename);
++ g_error("Unable to read file: %s", err->message);
++ }
++
++ if (vma_writer_add_config(vmaw, name, cdata, clen) != 0) {
++ unlink(archivename);
++ g_error("Unable to append config data %s (len = %zd)",
++ name, clen);
++ }
++ l = g_list_next(l);
++ }
++
++ int devcount = 0;
++ while (optind < argc) {
++ const char *path = argv[optind++];
++ char *devname = NULL;
++ path = extract_devname(path, &devname, devcount++);
++
++ Error *errp = NULL;
++ BlockBackend *target;
++
++ target = blk_new_open(path, NULL, NULL, 0, &errp);
++ if (!target) {
++ unlink(archivename);
++ g_error("bdrv_open '%s' failed - %s", path, error_get_pretty(errp));
++ }
++ int64_t size = blk_getlength(target);
++ int dev_id = vma_writer_register_stream(vmaw, devname, size);
++ if (dev_id <= 0) {
++ unlink(archivename);
++ g_error("vma_writer_register_stream '%s' failed", devname);
++ }
++
++ BackupJob *job = g_new0(BackupJob, 1);
++ job->len = size;
++ job->target = target;
++ job->vmaw = vmaw;
++ job->dev_id = dev_id;
++
++ Coroutine *co = qemu_coroutine_create(backup_run, job);
++ qemu_coroutine_enter(co);
++ }
++
++ VmaStatus vmastat;
++ int percent = 0;
++ int last_percent = -1;
++
++ if (devcount) {
++ while (1) {
++ main_loop_wait(false);
++ vma_writer_get_status(vmaw, &vmastat);
++
++ if (verbose) {
++
++ uint64_t total = 0;
++ uint64_t transferred = 0;
++ uint64_t zero_bytes = 0;
++
++ int i;
++ for (i = 0; i < 256; i++) {
++ if (vmastat.stream_info[i].size) {
++ total += vmastat.stream_info[i].size;
++ transferred += vmastat.stream_info[i].transferred;
++ zero_bytes += vmastat.stream_info[i].zero_bytes;
++ }
++ }
++ percent = (transferred*100)/total;
++ if (percent != last_percent) {
++ fprintf(stderr, "progress %d%% %zd/%zd %zd\n", percent,
++ transferred, total, zero_bytes);
++ fflush(stderr);
++
++ last_percent = percent;
++ }
++ }
++
++ if (vmastat.closed) {
++ break;
++ }
++ }
++ } else {
++ Coroutine *co = qemu_coroutine_create(backup_run_empty, vmaw);
++ qemu_coroutine_enter(co);
++ while (1) {
++ main_loop_wait(false);
++ vma_writer_get_status(vmaw, &vmastat);
++ if (vmastat.closed) {
++ break;
++ }
++ }
++ }
++
++ bdrv_drain_all();
++
++ vma_writer_get_status(vmaw, &vmastat);
++
++ if (verbose) {
++ for (i = 0; i < 256; i++) {
++ VmaStreamInfo *si = &vmastat.stream_info[i];
++ if (si->size) {
++ fprintf(stderr, "image %s: size=%zd zeros=%zd saved=%zd\n",
++ si->devname, si->size, si->zero_bytes,
++ si->size - si->zero_bytes);
++ }
++ }
++ }
++
++ if (vmastat.status < 0) {
++ unlink(archivename);
++ g_error("creating vma archive failed");
++ }
++
++ vma_writer_destroy(vmaw);
++ return 0;
++}
++
++static int dump_config(int argc, char **argv)
++{
++ int c, ret = 0;
++ const char *filename;
++ const char *config_name = "qemu-server.conf";
++
++ for (;;) {
++ c = getopt(argc, argv, "hc:");
++ if (c == -1) {
++ break;
++ }
++ switch (c) {
++ case '?':
++ case 'h':
++ help();
++ break;
++ case 'c':
++ config_name = optarg;
++ break;
++ default:
++ help();
++ }
++ }
++
++ /* Get the filename */
++ if ((optind + 1) != argc) {
++ help();
++ }
++ filename = argv[optind++];
++
++ Error *errp = NULL;
++ VmaReader *vmar = vma_reader_create(filename, &errp);
++
++ if (!vmar) {
++ g_error("%s", error_get_pretty(errp));
++ }
++
++ int found = 0;
++ GList *l = vma_reader_get_config_data(vmar);
++ while (l && l->data) {
++ VmaConfigData *cdata = (VmaConfigData *)l->data;
++ l = g_list_next(l);
++ if (strcmp(cdata->name, config_name) == 0) {
++ found = 1;
++ fwrite(cdata->data, cdata->len, 1, stdout);
++ break;
++ }
++ }
++
++ vma_reader_destroy(vmar);
++
++ bdrv_close_all();
++
++ if (!found) {
++ fprintf(stderr, "unable to find configuration data '%s'\n", config_name);
++ return -1;
++ }
++
++ return ret;
++}
++
++int main(int argc, char **argv)
++{
++ const char *cmdname;
++ Error *main_loop_err = NULL;
++
++ error_init(argv[0]);
++ module_call_init(MODULE_INIT_TRACE);
++ qemu_init_exec_dir(argv[0]);
++
++ if (qemu_init_main_loop(&main_loop_err)) {
++ g_error("%s", error_get_pretty(main_loop_err));
++ }
++
++ bdrv_init();
++ module_call_init(MODULE_INIT_QOM);
++
++ if (argc < 2) {
++ help();
++ }
++
++ cmdname = argv[1];
++ argc--; argv++;
++
++
++ if (!strcmp(cmdname, "list")) {
++ return list_content(argc, argv);
++ } else if (!strcmp(cmdname, "create")) {
++ return create_archive(argc, argv);
++ } else if (!strcmp(cmdname, "extract")) {
++ return extract_content(argc, argv);
++ } else if (!strcmp(cmdname, "verify")) {
++ return verify_content(argc, argv);
++ } else if (!strcmp(cmdname, "config")) {
++ return dump_config(argc, argv);
++ }
++
++ help();
++ return 0;
++}
+diff --git a/vma.h b/vma.h
+new file mode 100644
+index 0000000000..c895c97f6d
+--- /dev/null
++++ b/vma.h
+@@ -0,0 +1,150 @@
++/*
++ * VMA: Virtual Machine Archive
++ *
++ * Copyright (C) Proxmox Server Solutions
++ *
++ * Authors:
++ * Dietmar Maurer (dietmar@proxmox.com)
++ *
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++ * See the COPYING file in the top-level directory.
++ *
++ */
++
++#ifndef BACKUP_VMA_H
++#define BACKUP_VMA_H
++
++#include <uuid/uuid.h>
++#include "qapi/error.h"
++#include "block/block.h"
++
++#define VMA_BLOCK_BITS 12
++#define VMA_BLOCK_SIZE (1<<VMA_BLOCK_BITS)
++#define VMA_CLUSTER_BITS (VMA_BLOCK_BITS+4)
++#define VMA_CLUSTER_SIZE (1<<VMA_CLUSTER_BITS)
++
++#if VMA_CLUSTER_SIZE != 65536
++#error unexpected cluster size
++#endif
++
++#define VMA_EXTENT_HEADER_SIZE 512
++#define VMA_BLOCKS_PER_EXTENT 59
++#define VMA_MAX_CONFIGS 256
++
++#define VMA_MAX_EXTENT_SIZE \
++ (VMA_EXTENT_HEADER_SIZE+VMA_CLUSTER_SIZE*VMA_BLOCKS_PER_EXTENT)
++#if VMA_MAX_EXTENT_SIZE != 3867136
++#error unexpected VMA_EXTENT_SIZE
++#endif
++
++/* File Format Definitions */
++
++#define VMA_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|0x00))
++#define VMA_EXTENT_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|'E'))
++
++typedef struct VmaDeviceInfoHeader {
++ uint32_t devname_ptr; /* offset into blob_buffer table */
++ uint32_t reserved0;
++ uint64_t size; /* device size in bytes */
++ uint64_t reserved1;
++ uint64_t reserved2;
++} VmaDeviceInfoHeader;
++
++typedef struct VmaHeader {
++ uint32_t magic;
++ uint32_t version;
++ unsigned char uuid[16];
++ int64_t ctime;
++ unsigned char md5sum[16];
++
++ uint32_t blob_buffer_offset;
++ uint32_t blob_buffer_size;
++ uint32_t header_size;
++
++ unsigned char reserved[1984];
++
++ uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
++ uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
++
++ uint32_t reserved1;
++
++ VmaDeviceInfoHeader dev_info[256];
++} VmaHeader;
++
++typedef struct VmaExtentHeader {
++ uint32_t magic;
++ uint16_t reserved1;
++ uint16_t block_count;
++ unsigned char uuid[16];
++ unsigned char md5sum[16];
++ uint64_t blockinfo[VMA_BLOCKS_PER_EXTENT];
++} VmaExtentHeader;
++
++/* functions/definitions to read/write vma files */
++
++typedef struct VmaReader VmaReader;
++
++typedef struct VmaWriter VmaWriter;
++
++typedef struct VmaConfigData {
++ const char *name;
++ const void *data;
++ uint32_t len;
++} VmaConfigData;
++
++typedef struct VmaStreamInfo {
++ uint64_t size;
++ uint64_t cluster_count;
++ uint64_t transferred;
++ uint64_t zero_bytes;
++ int finished;
++ char *devname;
++} VmaStreamInfo;
++
++typedef struct VmaStatus {
++ int status;
++ bool closed;
++ char errmsg[8192];
++ char uuid_str[37];
++ VmaStreamInfo stream_info[256];
++} VmaStatus;
++
++typedef struct VmaDeviceInfo {
++ uint64_t size; /* device size in bytes */
++ const char *devname;
++} VmaDeviceInfo;
++
++VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp);
++int vma_writer_close(VmaWriter *vmaw, Error **errp);
++void vma_writer_error_propagate(VmaWriter *vmaw, Error **errp);
++void vma_writer_destroy(VmaWriter *vmaw);
++int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
++ size_t len);
++int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
++ size_t size);
++
++int64_t coroutine_fn vma_writer_write(VmaWriter *vmaw, uint8_t dev_id,
++ int64_t cluster_num,
++ const unsigned char *buf,
++ size_t *zero_bytes);
++
++int coroutine_fn vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id);
++int coroutine_fn vma_writer_flush_output(VmaWriter *vmaw);
++
++int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status);
++void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...);
++
++
++VmaReader *vma_reader_create(const char *filename, Error **errp);
++void vma_reader_destroy(VmaReader *vmar);
++VmaHeader *vma_reader_get_header(VmaReader *vmar);
++GList *vma_reader_get_config_data(VmaReader *vmar);
++VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id);
++int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id,
++ BlockBackend *target, bool write_zeroes,
++ Error **errp);
++int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
++ Error **errp);
++int vma_reader_verify(VmaReader *vmar, bool verbose, Error **errp);
++
++#endif /* BACKUP_VMA_H */
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Wolfgang Bumiller <w.bumiller@proxmox.com>
-Date: Mon, 6 Apr 2020 12:16:56 +0200
-Subject: [PATCH] PVE-Backup: modify job api
-
-Introduce a pause_count parameter to start a backup in
-paused mode. This way backups of multiple drives can be
-started up sequentially via the completion callback while
-having been started at the same point in time.
-
-Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
----
- block/backup.c | 3 +++
- block/replication.c | 2 +-
- blockdev.c | 3 ++-
- include/block/block_int.h | 1 +
- job.c | 2 +-
- 5 files changed, 8 insertions(+), 3 deletions(-)
-
-diff --git a/block/backup.c b/block/backup.c
-index 4f13bb20a5..5f373a4f9b 100644
---- a/block/backup.c
-+++ b/block/backup.c
-@@ -338,6 +338,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
- BlockdevOnError on_target_error,
- int creation_flags,
- BlockCompletionFunc *cb, void *opaque,
-+ int pause_count,
- JobTxn *txn, Error **errp)
- {
- int64_t len, target_len;
-@@ -471,6 +472,8 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
- block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
- &error_abort);
-
-+ job->common.job.pause_count += pause_count;
-+
- return &job->common;
-
- error:
-diff --git a/block/replication.c b/block/replication.c
-index 0c70215784..59270a0468 100644
---- a/block/replication.c
-+++ b/block/replication.c
-@@ -560,7 +560,7 @@ static void replication_start(ReplicationState *rs, ReplicationMode mode,
- 0, MIRROR_SYNC_MODE_NONE, NULL, 0, false, NULL,
- BLOCKDEV_ON_ERROR_REPORT,
- BLOCKDEV_ON_ERROR_REPORT, JOB_INTERNAL,
-- backup_job_completed, bs, NULL, &local_err);
-+ backup_job_completed, bs, 0, NULL, &local_err);
- if (local_err) {
- error_propagate(errp, local_err);
- backup_job_cleanup(bs);
-diff --git a/blockdev.c b/blockdev.c
-index 3848a9c8ab..5107c5445e 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -2832,7 +2832,8 @@ static BlockJob *do_backup_common(BackupCommon *backup,
- backup->filter_node_name,
- backup->on_source_error,
- backup->on_target_error,
-- job_flags, NULL, NULL, txn, errp);
-+ job_flags, NULL, NULL, 0, txn, errp);
-+
- return job;
- }
-
-diff --git a/include/block/block_int.h b/include/block/block_int.h
-index 38dec0275b..5094ae1e95 100644
---- a/include/block/block_int.h
-+++ b/include/block/block_int.h
-@@ -1254,6 +1254,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
- BlockdevOnError on_target_error,
- int creation_flags,
- BlockCompletionFunc *cb, void *opaque,
-+ int pause_count,
- JobTxn *txn, Error **errp);
-
- BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
-diff --git a/job.c b/job.c
-index 53be57a3a0..e82253e041 100644
---- a/job.c
-+++ b/job.c
-@@ -918,7 +918,7 @@ void job_start(Job *job)
- job->co = qemu_coroutine_create(job_co_entry, job);
- job->pause_count--;
- job->busy = true;
-- job->paused = false;
-+ job->paused = job->pause_count > 0;
- job_state_transition(job, JOB_STATUS_RUNNING);
- aio_co_enter(job->aio_context, job->co);
- }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dietmar Maurer <dietmar@proxmox.com>
+Date: Mon, 6 Apr 2020 12:16:58 +0200
+Subject: [PATCH] PVE-Backup: add backup-dump block driver
+
+- add backup-dump block driver block/backup-dump.c
+- move BackupBlockJob declaration from block/backup.c to include/block/block_int.h
+- block/backup.c - backup-job-create: also consider source cluster size
+- job.c: make job_should_pause non-static
+---
+ block/Makefile.objs | 1 +
+ block/backup-dump.c | 168 ++++++++++++++++++++++++++++++++++++++
+ block/backup.c | 23 ++----
+ include/block/block_int.h | 30 +++++++
+ job.c | 3 +-
+ 5 files changed, 206 insertions(+), 19 deletions(-)
+ create mode 100644 block/backup-dump.c
+
+diff --git a/block/Makefile.objs b/block/Makefile.objs
+index d1a9227b8f..9ea0477d0b 100644
+--- a/block/Makefile.objs
++++ b/block/Makefile.objs
+@@ -33,6 +33,7 @@ block-obj-$(CONFIG_CURL) += curl.o
+ block-obj-$(CONFIG_RBD) += rbd.o
+ block-obj-$(CONFIG_GLUSTERFS) += gluster.o
+ block-obj-$(CONFIG_LIBSSH) += ssh.o
++block-obj-y += backup-dump.o
+ block-obj-y += accounting.o dirty-bitmap.o
+ block-obj-y += write-threshold.o
+ block-obj-y += backup.o
+diff --git a/block/backup-dump.c b/block/backup-dump.c
+new file mode 100644
+index 0000000000..93d7f46950
+--- /dev/null
++++ b/block/backup-dump.c
+@@ -0,0 +1,168 @@
++/*
++ * BlockDriver to send backup data stream to a callback function
++ *
++ * Copyright (C) 2020 Proxmox Server Solutions GmbH
++ *
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++ * See the COPYING file in the top-level directory.
++ *
++ */
++
++#include "qemu/osdep.h"
++#include "qemu-common.h"
++#include "qom/object_interfaces.h"
++#include "block/block_int.h"
++
++typedef struct {
++ int dump_cb_block_size;
++ uint64_t byte_size;
++ BackupDumpFunc *dump_cb;
++ void *dump_cb_data;
++} BDRVBackupDumpState;
++
++static int qemu_backup_dump_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
++{
++ BDRVBackupDumpState *s = bs->opaque;
++
++ bdi->cluster_size = s->dump_cb_block_size;
++ return 0;
++}
++
++static int qemu_backup_dump_check_perm(
++ BlockDriverState *bs,
++ uint64_t perm,
++ uint64_t shared,
++ Error **errp)
++{
++ /* Nothing to do. */
++ return 0;
++}
++
++static void qemu_backup_dump_set_perm(
++ BlockDriverState *bs,
++ uint64_t perm,
++ uint64_t shared)
++{
++ /* Nothing to do. */
++}
++
++static void qemu_backup_dump_abort_perm_update(BlockDriverState *bs)
++{
++ /* Nothing to do. */
++}
++
++static void qemu_backup_dump_refresh_limits(BlockDriverState *bs, Error **errp)
++{
++ bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
++}
++
++static void qemu_backup_dump_close(BlockDriverState *bs)
++{
++ /* Nothing to do. */
++}
++
++static int64_t qemu_backup_dump_getlength(BlockDriverState *bs)
++{
++ BDRVBackupDumpState *s = bs->opaque;
++
++ return s->byte_size;
++}
++
++static coroutine_fn int qemu_backup_dump_co_writev(
++ BlockDriverState *bs,
++ int64_t sector_num,
++ int nb_sectors,
++ QEMUIOVector *qiov,
++ int flags)
++{
++ /* flags can be only values we set in supported_write_flags */
++ assert(flags == 0);
++
++ BDRVBackupDumpState *s = bs->opaque;
++ off_t offset = sector_num * BDRV_SECTOR_SIZE;
++
++ uint64_t written = 0;
++
++ for (int i = 0; i < qiov->niov; ++i) {
++ const struct iovec *v = &qiov->iov[i];
++
++ int rc = s->dump_cb(s->dump_cb_data, offset, v->iov_len, v->iov_base);
++ if (rc < 0) {
++ return rc;
++ }
++
++ if (rc != v->iov_len) {
++ return -EIO;
++ }
++
++ written += v->iov_len;
++ offset += v->iov_len;
++ }
++
++ return written;
++}
++
++static void qemu_backup_dump_child_perm(
++ BlockDriverState *bs,
++ BdrvChild *c,
++ BdrvChildRole role,
++ BlockReopenQueue *reopen_queue,
++ uint64_t perm, uint64_t shared,
++ uint64_t *nperm, uint64_t *nshared)
++{
++ *nperm = BLK_PERM_ALL;
++ *nshared = BLK_PERM_ALL;
++}
++
++static BlockDriver bdrv_backup_dump_drive = {
++ .format_name = "backup-dump-drive",
++ .protocol_name = "backup-dump",
++ .instance_size = sizeof(BDRVBackupDumpState),
++
++ .bdrv_close = qemu_backup_dump_close,
++ .bdrv_has_zero_init = bdrv_has_zero_init_1,
++ .bdrv_getlength = qemu_backup_dump_getlength,
++ .bdrv_get_info = qemu_backup_dump_get_info,
++
++ .bdrv_co_writev = qemu_backup_dump_co_writev,
++
++ .bdrv_refresh_limits = qemu_backup_dump_refresh_limits,
++ .bdrv_check_perm = qemu_backup_dump_check_perm,
++ .bdrv_set_perm = qemu_backup_dump_set_perm,
++ .bdrv_abort_perm_update = qemu_backup_dump_abort_perm_update,
++ .bdrv_child_perm = qemu_backup_dump_child_perm,
++};
++
++static void bdrv_backup_dump_init(void)
++{
++ bdrv_register(&bdrv_backup_dump_drive);
++}
++
++block_init(bdrv_backup_dump_init);
++
++
++BlockDriverState *bdrv_backup_dump_create(
++ int dump_cb_block_size,
++ uint64_t byte_size,
++ BackupDumpFunc *dump_cb,
++ void *dump_cb_data,
++ Error **errp)
++{
++ BDRVBackupDumpState *state;
++ BlockDriverState *bs = bdrv_new_open_driver(
++ &bdrv_backup_dump_drive, NULL, BDRV_O_RDWR, errp);
++
++ if (!bs) {
++ return NULL;
++ }
++
++ bs->total_sectors = byte_size / BDRV_SECTOR_SIZE;
++ bs->opaque = state = g_new0(BDRVBackupDumpState, 1);
++
++ state->dump_cb_block_size = dump_cb_block_size;
++ state->byte_size = byte_size;
++ state->dump_cb = dump_cb;
++ state->dump_cb_data = dump_cb_data;
++
++ return bs;
++}
+diff --git a/block/backup.c b/block/backup.c
+index 4f13bb20a5..cd42236b79 100644
+--- a/block/backup.c
++++ b/block/backup.c
+@@ -32,24 +32,6 @@
+
+ #define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
+
+-typedef struct BackupBlockJob {
+- BlockJob common;
+- BlockDriverState *backup_top;
+- BlockDriverState *source_bs;
+-
+- BdrvDirtyBitmap *sync_bitmap;
+-
+- MirrorSyncMode sync_mode;
+- BitmapSyncMode bitmap_mode;
+- BlockdevOnError on_source_error;
+- BlockdevOnError on_target_error;
+- uint64_t len;
+- uint64_t bytes_read;
+- int64_t cluster_size;
+-
+- BlockCopyState *bcs;
+-} BackupBlockJob;
+-
+ static const BlockJobDriver backup_job_driver;
+
+ static void backup_progress_bytes_callback(int64_t bytes, void *opaque)
+@@ -422,6 +404,11 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
+ goto error;
+ }
+
++ BlockDriverInfo bdi;
++ if (bdrv_get_info(bs, &bdi) == 0) {
++ cluster_size = MAX(cluster_size, bdi.cluster_size);
++ }
++
+ /*
+ * If source is in backing chain of target assume that target is going to be
+ * used for "image fleecing", i.e. it should represent a kind of snapshot of
+diff --git a/include/block/block_int.h b/include/block/block_int.h
+index 38dec0275b..1efb1f527c 100644
+--- a/include/block/block_int.h
++++ b/include/block/block_int.h
+@@ -62,6 +62,36 @@
+
+ #define BLOCK_PROBE_BUF_SIZE 512
+
++typedef int BackupDumpFunc(void *opaque, uint64_t offset, uint64_t bytes, const void *buf);
++
++BlockDriverState *bdrv_backuo_dump_create(
++ int dump_cb_block_size,
++ uint64_t byte_size,
++ BackupDumpFunc *dump_cb,
++ void *dump_cb_data,
++ Error **errp);
++
++// Needs to be defined here, since it's used in blockdev.c to detect PVE backup
++// jobs with source_bs
++typedef struct BlockCopyState BlockCopyState;
++typedef struct BackupBlockJob {
++ BlockJob common;
++ BlockDriverState *backup_top;
++ BlockDriverState *source_bs;
++
++ BdrvDirtyBitmap *sync_bitmap;
++
++ MirrorSyncMode sync_mode;
++ BitmapSyncMode bitmap_mode;
++ BlockdevOnError on_source_error;
++ BlockdevOnError on_target_error;
++ uint64_t len;
++ uint64_t bytes_read;
++ int64_t cluster_size;
++
++ BlockCopyState *bcs;
++} BackupBlockJob;
++
+ enum BdrvTrackedRequestType {
+ BDRV_TRACKED_READ,
+ BDRV_TRACKED_WRITE,
+diff --git a/job.c b/job.c
+index 53be57a3a0..b8139c80a4 100644
+--- a/job.c
++++ b/job.c
+@@ -269,7 +269,8 @@ static bool job_started(Job *job)
+ return job->co;
+ }
+
+-static bool job_should_pause(Job *job)
++bool job_should_pause(Job *job);
++bool job_should_pause(Job *job)
+ {
+ return job->pause_count > 0;
+ }
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Dietmar Maurer <dietmar@proxmox.com>
-Date: Mon, 6 Apr 2020 12:16:57 +0200
-Subject: [PATCH] PVE-Backup: add vma backup format code
-
----
- Makefile | 3 +-
- Makefile.objs | 1 +
- vma-reader.c | 857 ++++++++++++++++++++++++++++++++++++++++++++++++++
- vma-writer.c | 790 ++++++++++++++++++++++++++++++++++++++++++++++
- vma.c | 839 ++++++++++++++++++++++++++++++++++++++++++++++++
- vma.h | 150 +++++++++
- 6 files changed, 2639 insertions(+), 1 deletion(-)
- create mode 100644 vma-reader.c
- create mode 100644 vma-writer.c
- create mode 100644 vma.c
- create mode 100644 vma.h
-
-diff --git a/Makefile b/Makefile
-index 13dd708c4a..7b8c17ce2d 100644
---- a/Makefile
-+++ b/Makefile
-@@ -479,7 +479,7 @@ dummy := $(call unnest-vars,, \
-
- include $(SRC_PATH)/tests/Makefile.include
-
--all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
-+all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) vma$(EXESUF) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
-
- qemu-version.h: FORCE
- $(call quiet-command, \
-@@ -602,6 +602,7 @@ qemu-img$(EXESUF): qemu-img.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io
- qemu-nbd$(EXESUF): qemu-nbd.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
- qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
- qemu-storage-daemon$(EXESUF): qemu-storage-daemon.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(chardev-obj-y) $(io-obj-y) $(qom-obj-y) $(storage-daemon-obj-y) $(COMMON_LDADDS)
-+vma$(EXESUF): vma.o vma-reader.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
-
- qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
-
-diff --git a/Makefile.objs b/Makefile.objs
-index a1307c12a8..ade7b17a69 100644
---- a/Makefile.objs
-+++ b/Makefile.objs
-@@ -17,6 +17,7 @@ block-obj-y = block/ nbd/ scsi/
- block-obj-y += block.o blockjob.o job.o
- block-obj-y += qemu-io-cmds.o
- block-obj-$(CONFIG_REPLICATION) += replication.o
-+block-obj-y += vma-writer.o
-
- block-obj-m = block/
-
-diff --git a/vma-reader.c b/vma-reader.c
-new file mode 100644
-index 0000000000..2b1d1cdab3
---- /dev/null
-+++ b/vma-reader.c
-@@ -0,0 +1,857 @@
-+/*
-+ * VMA: Virtual Machine Archive
-+ *
-+ * Copyright (C) 2012 Proxmox Server Solutions
-+ *
-+ * Authors:
-+ * Dietmar Maurer (dietmar@proxmox.com)
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ *
-+ */
-+
-+#include "qemu/osdep.h"
-+#include <glib.h>
-+#include <uuid/uuid.h>
-+
-+#include "qemu-common.h"
-+#include "qemu/timer.h"
-+#include "qemu/ratelimit.h"
-+#include "vma.h"
-+#include "block/block.h"
-+#include "sysemu/block-backend.h"
-+
-+static unsigned char zero_vma_block[VMA_BLOCK_SIZE];
-+
-+typedef struct VmaRestoreState {
-+ BlockBackend *target;
-+ bool write_zeroes;
-+ unsigned long *bitmap;
-+ int bitmap_size;
-+} VmaRestoreState;
-+
-+struct VmaReader {
-+ int fd;
-+ GChecksum *md5csum;
-+ GHashTable *blob_hash;
-+ unsigned char *head_data;
-+ VmaDeviceInfo devinfo[256];
-+ VmaRestoreState rstate[256];
-+ GList *cdata_list;
-+ guint8 vmstate_stream;
-+ uint32_t vmstate_clusters;
-+ /* to show restore percentage if run with -v */
-+ time_t start_time;
-+ int64_t cluster_count;
-+ int64_t clusters_read;
-+ int64_t zero_cluster_data;
-+ int64_t partial_zero_cluster_data;
-+ int clusters_read_per;
-+};
-+
-+static guint
-+g_int32_hash(gconstpointer v)
-+{
-+ return *(const uint32_t *)v;
-+}
-+
-+static gboolean
-+g_int32_equal(gconstpointer v1, gconstpointer v2)
-+{
-+ return *((const uint32_t *)v1) == *((const uint32_t *)v2);
-+}
-+
-+static int vma_reader_get_bitmap(VmaRestoreState *rstate, int64_t cluster_num)
-+{
-+ assert(rstate);
-+ assert(rstate->bitmap);
-+
-+ unsigned long val, idx, bit;
-+
-+ idx = cluster_num / BITS_PER_LONG;
-+
-+ assert(rstate->bitmap_size > idx);
-+
-+ bit = cluster_num % BITS_PER_LONG;
-+ val = rstate->bitmap[idx];
-+
-+ return !!(val & (1UL << bit));
-+}
-+
-+static void vma_reader_set_bitmap(VmaRestoreState *rstate, int64_t cluster_num,
-+ int dirty)
-+{
-+ assert(rstate);
-+ assert(rstate->bitmap);
-+
-+ unsigned long val, idx, bit;
-+
-+ idx = cluster_num / BITS_PER_LONG;
-+
-+ assert(rstate->bitmap_size > idx);
-+
-+ bit = cluster_num % BITS_PER_LONG;
-+ val = rstate->bitmap[idx];
-+ if (dirty) {
-+ if (!(val & (1UL << bit))) {
-+ val |= 1UL << bit;
-+ }
-+ } else {
-+ if (val & (1UL << bit)) {
-+ val &= ~(1UL << bit);
-+ }
-+ }
-+ rstate->bitmap[idx] = val;
-+}
-+
-+typedef struct VmaBlob {
-+ uint32_t start;
-+ uint32_t len;
-+ void *data;
-+} VmaBlob;
-+
-+static const VmaBlob *get_header_blob(VmaReader *vmar, uint32_t pos)
-+{
-+ assert(vmar);
-+ assert(vmar->blob_hash);
-+
-+ return g_hash_table_lookup(vmar->blob_hash, &pos);
-+}
-+
-+static const char *get_header_str(VmaReader *vmar, uint32_t pos)
-+{
-+ const VmaBlob *blob = get_header_blob(vmar, pos);
-+ if (!blob) {
-+ return NULL;
-+ }
-+ const char *res = (char *)blob->data;
-+ if (res[blob->len-1] != '\0') {
-+ return NULL;
-+ }
-+ return res;
-+}
-+
-+static ssize_t
-+safe_read(int fd, unsigned char *buf, size_t count)
-+{
-+ ssize_t n;
-+
-+ do {
-+ n = read(fd, buf, count);
-+ } while (n < 0 && errno == EINTR);
-+
-+ return n;
-+}
-+
-+static ssize_t
-+full_read(int fd, unsigned char *buf, size_t len)
-+{
-+ ssize_t n;
-+ size_t total;
-+
-+ total = 0;
-+
-+ while (len > 0) {
-+ n = safe_read(fd, buf, len);
-+
-+ if (n == 0) {
-+ return total;
-+ }
-+
-+ if (n <= 0) {
-+ break;
-+ }
-+
-+ buf += n;
-+ total += n;
-+ len -= n;
-+ }
-+
-+ if (len) {
-+ return -1;
-+ }
-+
-+ return total;
-+}
-+
-+void vma_reader_destroy(VmaReader *vmar)
-+{
-+ assert(vmar);
-+
-+ if (vmar->fd >= 0) {
-+ close(vmar->fd);
-+ }
-+
-+ if (vmar->cdata_list) {
-+ g_list_free(vmar->cdata_list);
-+ }
-+
-+ int i;
-+ for (i = 1; i < 256; i++) {
-+ if (vmar->rstate[i].bitmap) {
-+ g_free(vmar->rstate[i].bitmap);
-+ }
-+ }
-+
-+ if (vmar->md5csum) {
-+ g_checksum_free(vmar->md5csum);
-+ }
-+
-+ if (vmar->blob_hash) {
-+ g_hash_table_destroy(vmar->blob_hash);
-+ }
-+
-+ if (vmar->head_data) {
-+ g_free(vmar->head_data);
-+ }
-+
-+ g_free(vmar);
-+
-+};
-+
-+static int vma_reader_read_head(VmaReader *vmar, Error **errp)
-+{
-+ assert(vmar);
-+ assert(errp);
-+ assert(*errp == NULL);
-+
-+ unsigned char md5sum[16];
-+ int i;
-+ int ret = 0;
-+
-+ vmar->head_data = g_malloc(sizeof(VmaHeader));
-+
-+ if (full_read(vmar->fd, vmar->head_data, sizeof(VmaHeader)) !=
-+ sizeof(VmaHeader)) {
-+ error_setg(errp, "can't read vma header - %s",
-+ errno ? g_strerror(errno) : "got EOF");
-+ return -1;
-+ }
-+
-+ VmaHeader *h = (VmaHeader *)vmar->head_data;
-+
-+ if (h->magic != VMA_MAGIC) {
-+ error_setg(errp, "not a vma file - wrong magic number");
-+ return -1;
-+ }
-+
-+ uint32_t header_size = GUINT32_FROM_BE(h->header_size);
-+ int need = header_size - sizeof(VmaHeader);
-+ if (need <= 0) {
-+ error_setg(errp, "wrong vma header size %d", header_size);
-+ return -1;
-+ }
-+
-+ vmar->head_data = g_realloc(vmar->head_data, header_size);
-+ h = (VmaHeader *)vmar->head_data;
-+
-+ if (full_read(vmar->fd, vmar->head_data + sizeof(VmaHeader), need) !=
-+ need) {
-+ error_setg(errp, "can't read vma header data - %s",
-+ errno ? g_strerror(errno) : "got EOF");
-+ return -1;
-+ }
-+
-+ memcpy(md5sum, h->md5sum, 16);
-+ memset(h->md5sum, 0, 16);
-+
-+ g_checksum_reset(vmar->md5csum);
-+ g_checksum_update(vmar->md5csum, vmar->head_data, header_size);
-+ gsize csize = 16;
-+ g_checksum_get_digest(vmar->md5csum, (guint8 *)(h->md5sum), &csize);
-+
-+ if (memcmp(md5sum, h->md5sum, 16) != 0) {
-+ error_setg(errp, "wrong vma header chechsum");
-+ return -1;
-+ }
-+
-+ /* we can modify header data after checksum verify */
-+ h->header_size = header_size;
-+
-+ h->version = GUINT32_FROM_BE(h->version);
-+ if (h->version != 1) {
-+ error_setg(errp, "wrong vma version %d", h->version);
-+ return -1;
-+ }
-+
-+ h->ctime = GUINT64_FROM_BE(h->ctime);
-+ h->blob_buffer_offset = GUINT32_FROM_BE(h->blob_buffer_offset);
-+ h->blob_buffer_size = GUINT32_FROM_BE(h->blob_buffer_size);
-+
-+ uint32_t bstart = h->blob_buffer_offset + 1;
-+ uint32_t bend = h->blob_buffer_offset + h->blob_buffer_size;
-+
-+ if (bstart <= sizeof(VmaHeader)) {
-+ error_setg(errp, "wrong vma blob buffer offset %d",
-+ h->blob_buffer_offset);
-+ return -1;
-+ }
-+
-+ if (bend > header_size) {
-+ error_setg(errp, "wrong vma blob buffer size %d/%d",
-+ h->blob_buffer_offset, h->blob_buffer_size);
-+ return -1;
-+ }
-+
-+ while ((bstart + 2) <= bend) {
-+ uint32_t size = vmar->head_data[bstart] +
-+ (vmar->head_data[bstart+1] << 8);
-+ if ((bstart + size + 2) <= bend) {
-+ VmaBlob *blob = g_new0(VmaBlob, 1);
-+ blob->start = bstart - h->blob_buffer_offset;
-+ blob->len = size;
-+ blob->data = vmar->head_data + bstart + 2;
-+ g_hash_table_insert(vmar->blob_hash, &blob->start, blob);
-+ }
-+ bstart += size + 2;
-+ }
-+
-+
-+ int count = 0;
-+ for (i = 1; i < 256; i++) {
-+ VmaDeviceInfoHeader *dih = &h->dev_info[i];
-+ uint32_t devname_ptr = GUINT32_FROM_BE(dih->devname_ptr);
-+ uint64_t size = GUINT64_FROM_BE(dih->size);
-+ const char *devname = get_header_str(vmar, devname_ptr);
-+
-+ if (size && devname) {
-+ count++;
-+ vmar->devinfo[i].size = size;
-+ vmar->devinfo[i].devname = devname;
-+
-+ if (strcmp(devname, "vmstate") == 0) {
-+ vmar->vmstate_stream = i;
-+ }
-+ }
-+ }
-+
-+ for (i = 0; i < VMA_MAX_CONFIGS; i++) {
-+ uint32_t name_ptr = GUINT32_FROM_BE(h->config_names[i]);
-+ uint32_t data_ptr = GUINT32_FROM_BE(h->config_data[i]);
-+
-+ if (!(name_ptr && data_ptr)) {
-+ continue;
-+ }
-+ const char *name = get_header_str(vmar, name_ptr);
-+ const VmaBlob *blob = get_header_blob(vmar, data_ptr);
-+
-+ if (!(name && blob)) {
-+ error_setg(errp, "vma contains invalid data pointers");
-+ return -1;
-+ }
-+
-+ VmaConfigData *cdata = g_new0(VmaConfigData, 1);
-+ cdata->name = name;
-+ cdata->data = blob->data;
-+ cdata->len = blob->len;
-+
-+ vmar->cdata_list = g_list_append(vmar->cdata_list, cdata);
-+ }
-+
-+ return ret;
-+};
-+
-+VmaReader *vma_reader_create(const char *filename, Error **errp)
-+{
-+ assert(filename);
-+ assert(errp);
-+
-+ VmaReader *vmar = g_new0(VmaReader, 1);
-+
-+ if (strcmp(filename, "-") == 0) {
-+ vmar->fd = dup(0);
-+ } else {
-+ vmar->fd = open(filename, O_RDONLY);
-+ }
-+
-+ if (vmar->fd < 0) {
-+ error_setg(errp, "can't open file %s - %s\n", filename,
-+ g_strerror(errno));
-+ goto err;
-+ }
-+
-+ vmar->md5csum = g_checksum_new(G_CHECKSUM_MD5);
-+ if (!vmar->md5csum) {
-+ error_setg(errp, "can't allocate cmsum\n");
-+ goto err;
-+ }
-+
-+ vmar->blob_hash = g_hash_table_new_full(g_int32_hash, g_int32_equal,
-+ NULL, g_free);
-+
-+ if (vma_reader_read_head(vmar, errp) < 0) {
-+ goto err;
-+ }
-+
-+ return vmar;
-+
-+err:
-+ if (vmar) {
-+ vma_reader_destroy(vmar);
-+ }
-+
-+ return NULL;
-+}
-+
-+VmaHeader *vma_reader_get_header(VmaReader *vmar)
-+{
-+ assert(vmar);
-+ assert(vmar->head_data);
-+
-+ return (VmaHeader *)(vmar->head_data);
-+}
-+
-+GList *vma_reader_get_config_data(VmaReader *vmar)
-+{
-+ assert(vmar);
-+ assert(vmar->head_data);
-+
-+ return vmar->cdata_list;
-+}
-+
-+VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id)
-+{
-+ assert(vmar);
-+ assert(dev_id);
-+
-+ if (vmar->devinfo[dev_id].size && vmar->devinfo[dev_id].devname) {
-+ return &vmar->devinfo[dev_id];
-+ }
-+
-+ return NULL;
-+}
-+
-+static void allocate_rstate(VmaReader *vmar, guint8 dev_id,
-+ BlockBackend *target, bool write_zeroes)
-+{
-+ assert(vmar);
-+ assert(dev_id);
-+
-+ vmar->rstate[dev_id].target = target;
-+ vmar->rstate[dev_id].write_zeroes = write_zeroes;
-+
-+ int64_t size = vmar->devinfo[dev_id].size;
-+
-+ int64_t bitmap_size = (size/BDRV_SECTOR_SIZE) +
-+ (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG - 1;
-+ bitmap_size /= (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG;
-+
-+ vmar->rstate[dev_id].bitmap_size = bitmap_size;
-+ vmar->rstate[dev_id].bitmap = g_new0(unsigned long, bitmap_size);
-+
-+ vmar->cluster_count += size/VMA_CLUSTER_SIZE;
-+}
-+
-+int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockBackend *target,
-+ bool write_zeroes, Error **errp)
-+{
-+ assert(vmar);
-+ assert(target != NULL);
-+ assert(dev_id);
-+ assert(vmar->rstate[dev_id].target == NULL);
-+
-+ int64_t size = blk_getlength(target);
-+ int64_t size_diff = size - vmar->devinfo[dev_id].size;
-+
-+ /* storage types can have different size restrictions, so it
-+ * is not always possible to create an image with exact size.
-+ * So we tolerate a size difference up to 4MB.
-+ */
-+ if ((size_diff < 0) || (size_diff > 4*1024*1024)) {
-+ error_setg(errp, "vma_reader_register_bs for stream %s failed - "
-+ "unexpected size %zd != %zd", vmar->devinfo[dev_id].devname,
-+ size, vmar->devinfo[dev_id].size);
-+ return -1;
-+ }
-+
-+ allocate_rstate(vmar, dev_id, target, write_zeroes);
-+
-+ return 0;
-+}
-+
-+static ssize_t safe_write(int fd, void *buf, size_t count)
-+{
-+ ssize_t n;
-+
-+ do {
-+ n = write(fd, buf, count);
-+ } while (n < 0 && errno == EINTR);
-+
-+ return n;
-+}
-+
-+static size_t full_write(int fd, void *buf, size_t len)
-+{
-+ ssize_t n;
-+ size_t total;
-+
-+ total = 0;
-+
-+ while (len > 0) {
-+ n = safe_write(fd, buf, len);
-+ if (n < 0) {
-+ return n;
-+ }
-+ buf += n;
-+ total += n;
-+ len -= n;
-+ }
-+
-+ if (len) {
-+ /* incomplete write ? */
-+ return -1;
-+ }
-+
-+ return total;
-+}
-+
-+static int restore_write_data(VmaReader *vmar, guint8 dev_id,
-+ BlockBackend *target, int vmstate_fd,
-+ unsigned char *buf, int64_t sector_num,
-+ int nb_sectors, Error **errp)
-+{
-+ assert(vmar);
-+
-+ if (dev_id == vmar->vmstate_stream) {
-+ if (vmstate_fd >= 0) {
-+ int len = nb_sectors * BDRV_SECTOR_SIZE;
-+ int res = full_write(vmstate_fd, buf, len);
-+ if (res < 0) {
-+ error_setg(errp, "write vmstate failed %d", res);
-+ return -1;
-+ }
-+ }
-+ } else {
-+ int res = blk_pwrite(target, sector_num * BDRV_SECTOR_SIZE, buf, nb_sectors * BDRV_SECTOR_SIZE, 0);
-+ if (res < 0) {
-+ error_setg(errp, "blk_pwrite to %s failed (%d)",
-+ bdrv_get_device_name(blk_bs(target)), res);
-+ return -1;
-+ }
-+ }
-+ return 0;
-+}
-+
-+static int restore_extent(VmaReader *vmar, unsigned char *buf,
-+ int extent_size, int vmstate_fd,
-+ bool verbose, bool verify, Error **errp)
-+{
-+ assert(vmar);
-+ assert(buf);
-+
-+ VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
-+ int start = VMA_EXTENT_HEADER_SIZE;
-+ int i;
-+
-+ for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
-+ uint64_t block_info = GUINT64_FROM_BE(ehead->blockinfo[i]);
-+ uint64_t cluster_num = block_info & 0xffffffff;
-+ uint8_t dev_id = (block_info >> 32) & 0xff;
-+ uint16_t mask = block_info >> (32+16);
-+ int64_t max_sector;
-+
-+ if (!dev_id) {
-+ continue;
-+ }
-+
-+ VmaRestoreState *rstate = &vmar->rstate[dev_id];
-+ BlockBackend *target = NULL;
-+
-+ if (dev_id != vmar->vmstate_stream) {
-+ target = rstate->target;
-+ if (!verify && !target) {
-+ error_setg(errp, "got wrong dev id %d", dev_id);
-+ return -1;
-+ }
-+
-+ if (vma_reader_get_bitmap(rstate, cluster_num)) {
-+ error_setg(errp, "found duplicated cluster %zd for stream %s",
-+ cluster_num, vmar->devinfo[dev_id].devname);
-+ return -1;
-+ }
-+ vma_reader_set_bitmap(rstate, cluster_num, 1);
-+
-+ max_sector = vmar->devinfo[dev_id].size/BDRV_SECTOR_SIZE;
-+ } else {
-+ max_sector = G_MAXINT64;
-+ if (cluster_num != vmar->vmstate_clusters) {
-+ error_setg(errp, "found out of order vmstate data");
-+ return -1;
-+ }
-+ vmar->vmstate_clusters++;
-+ }
-+
-+ vmar->clusters_read++;
-+
-+ if (verbose) {
-+ time_t duration = time(NULL) - vmar->start_time;
-+ int percent = (vmar->clusters_read*100)/vmar->cluster_count;
-+ if (percent != vmar->clusters_read_per) {
-+ printf("progress %d%% (read %zd bytes, duration %zd sec)\n",
-+ percent, vmar->clusters_read*VMA_CLUSTER_SIZE,
-+ duration);
-+ fflush(stdout);
-+ vmar->clusters_read_per = percent;
-+ }
-+ }
-+
-+ /* try to write whole clusters to speedup restore */
-+ if (mask == 0xffff) {
-+ if ((start + VMA_CLUSTER_SIZE) > extent_size) {
-+ error_setg(errp, "short vma extent - too many blocks");
-+ return -1;
-+ }
-+ int64_t sector_num = (cluster_num * VMA_CLUSTER_SIZE) /
-+ BDRV_SECTOR_SIZE;
-+ int64_t end_sector = sector_num +
-+ VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE;
-+
-+ if (end_sector > max_sector) {
-+ end_sector = max_sector;
-+ }
-+
-+ if (end_sector <= sector_num) {
-+ error_setg(errp, "got wrong block address - write beyond end");
-+ return -1;
-+ }
-+
-+ if (!verify) {
-+ int nb_sectors = end_sector - sector_num;
-+ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
-+ buf + start, sector_num, nb_sectors,
-+ errp) < 0) {
-+ return -1;
-+ }
-+ }
-+
-+ start += VMA_CLUSTER_SIZE;
-+ } else {
-+ int j;
-+ int bit = 1;
-+
-+ for (j = 0; j < 16; j++) {
-+ int64_t sector_num = (cluster_num*VMA_CLUSTER_SIZE +
-+ j*VMA_BLOCK_SIZE)/BDRV_SECTOR_SIZE;
-+
-+ int64_t end_sector = sector_num +
-+ VMA_BLOCK_SIZE/BDRV_SECTOR_SIZE;
-+ if (end_sector > max_sector) {
-+ end_sector = max_sector;
-+ }
-+
-+ if (mask & bit) {
-+ if ((start + VMA_BLOCK_SIZE) > extent_size) {
-+ error_setg(errp, "short vma extent - too many blocks");
-+ return -1;
-+ }
-+
-+ if (end_sector <= sector_num) {
-+ error_setg(errp, "got wrong block address - "
-+ "write beyond end");
-+ return -1;
-+ }
-+
-+ if (!verify) {
-+ int nb_sectors = end_sector - sector_num;
-+ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
-+ buf + start, sector_num,
-+ nb_sectors, errp) < 0) {
-+ return -1;
-+ }
-+ }
-+
-+ start += VMA_BLOCK_SIZE;
-+
-+ } else {
-+
-+
-+ if (end_sector > sector_num) {
-+ /* Todo: use bdrv_co_write_zeroes (but that need to
-+ * be run inside coroutine?)
-+ */
-+ int nb_sectors = end_sector - sector_num;
-+ int zero_size = BDRV_SECTOR_SIZE*nb_sectors;
-+ vmar->zero_cluster_data += zero_size;
-+ if (mask != 0) {
-+ vmar->partial_zero_cluster_data += zero_size;
-+ }
-+
-+ if (rstate->write_zeroes && !verify) {
-+ if (restore_write_data(vmar, dev_id, target, vmstate_fd,
-+ zero_vma_block, sector_num,
-+ nb_sectors, errp) < 0) {
-+ return -1;
-+ }
-+ }
-+ }
-+ }
-+
-+ bit = bit << 1;
-+ }
-+ }
-+ }
-+
-+ if (start != extent_size) {
-+ error_setg(errp, "vma extent error - missing blocks");
-+ return -1;
-+ }
-+
-+ return 0;
-+}
-+
-+static int vma_reader_restore_full(VmaReader *vmar, int vmstate_fd,
-+ bool verbose, bool verify,
-+ Error **errp)
-+{
-+ assert(vmar);
-+ assert(vmar->head_data);
-+
-+ int ret = 0;
-+ unsigned char buf[VMA_MAX_EXTENT_SIZE];
-+ int buf_pos = 0;
-+ unsigned char md5sum[16];
-+ VmaHeader *h = (VmaHeader *)vmar->head_data;
-+
-+ vmar->start_time = time(NULL);
-+
-+ while (1) {
-+ int bytes = full_read(vmar->fd, buf + buf_pos, sizeof(buf) - buf_pos);
-+ if (bytes < 0) {
-+ error_setg(errp, "read failed - %s", g_strerror(errno));
-+ return -1;
-+ }
-+
-+ buf_pos += bytes;
-+
-+ if (!buf_pos) {
-+ break; /* EOF */
-+ }
-+
-+ if (buf_pos < VMA_EXTENT_HEADER_SIZE) {
-+ error_setg(errp, "read short extent (%d bytes)", buf_pos);
-+ return -1;
-+ }
-+
-+ VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
-+
-+ /* extract md5sum */
-+ memcpy(md5sum, ehead->md5sum, sizeof(ehead->md5sum));
-+ memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
-+
-+ g_checksum_reset(vmar->md5csum);
-+ g_checksum_update(vmar->md5csum, buf, VMA_EXTENT_HEADER_SIZE);
-+ gsize csize = 16;
-+ g_checksum_get_digest(vmar->md5csum, ehead->md5sum, &csize);
-+
-+ if (memcmp(md5sum, ehead->md5sum, 16) != 0) {
-+ error_setg(errp, "wrong vma extent header chechsum");
-+ return -1;
-+ }
-+
-+ if (memcmp(h->uuid, ehead->uuid, sizeof(ehead->uuid)) != 0) {
-+ error_setg(errp, "wrong vma extent uuid");
-+ return -1;
-+ }
-+
-+ if (ehead->magic != VMA_EXTENT_MAGIC || ehead->reserved1 != 0) {
-+ error_setg(errp, "wrong vma extent header magic");
-+ return -1;
-+ }
-+
-+ int block_count = GUINT16_FROM_BE(ehead->block_count);
-+ int extent_size = VMA_EXTENT_HEADER_SIZE + block_count*VMA_BLOCK_SIZE;
-+
-+ if (buf_pos < extent_size) {
-+ error_setg(errp, "short vma extent (%d < %d)", buf_pos,
-+ extent_size);
-+ return -1;
-+ }
-+
-+ if (restore_extent(vmar, buf, extent_size, vmstate_fd, verbose,
-+ verify, errp) < 0) {
-+ return -1;
-+ }
-+
-+ if (buf_pos > extent_size) {
-+ memmove(buf, buf + extent_size, buf_pos - extent_size);
-+ buf_pos = buf_pos - extent_size;
-+ } else {
-+ buf_pos = 0;
-+ }
-+ }
-+
-+ bdrv_drain_all();
-+
-+ int i;
-+ for (i = 1; i < 256; i++) {
-+ VmaRestoreState *rstate = &vmar->rstate[i];
-+ if (!rstate->target) {
-+ continue;
-+ }
-+
-+ if (blk_flush(rstate->target) < 0) {
-+ error_setg(errp, "vma blk_flush %s failed",
-+ vmar->devinfo[i].devname);
-+ return -1;
-+ }
-+
-+ if (vmar->devinfo[i].size &&
-+ (strcmp(vmar->devinfo[i].devname, "vmstate") != 0)) {
-+ assert(rstate->bitmap);
-+
-+ int64_t cluster_num, end;
-+
-+ end = (vmar->devinfo[i].size + VMA_CLUSTER_SIZE - 1) /
-+ VMA_CLUSTER_SIZE;
-+
-+ for (cluster_num = 0; cluster_num < end; cluster_num++) {
-+ if (!vma_reader_get_bitmap(rstate, cluster_num)) {
-+ error_setg(errp, "detected missing cluster %zd "
-+ "for stream %s", cluster_num,
-+ vmar->devinfo[i].devname);
-+ return -1;
-+ }
-+ }
-+ }
-+ }
-+
-+ if (verbose) {
-+ if (vmar->clusters_read) {
-+ printf("total bytes read %zd, sparse bytes %zd (%.3g%%)\n",
-+ vmar->clusters_read*VMA_CLUSTER_SIZE,
-+ vmar->zero_cluster_data,
-+ (double)(100.0*vmar->zero_cluster_data)/
-+ (vmar->clusters_read*VMA_CLUSTER_SIZE));
-+
-+ int64_t datasize = vmar->clusters_read*VMA_CLUSTER_SIZE-vmar->zero_cluster_data;
-+ if (datasize) { // this does not make sense for empty files
-+ printf("space reduction due to 4K zero blocks %.3g%%\n",
-+ (double)(100.0*vmar->partial_zero_cluster_data) / datasize);
-+ }
-+ } else {
-+ printf("vma archive contains no image data\n");
-+ }
-+ }
-+ return ret;
-+}
-+
-+int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
-+ Error **errp)
-+{
-+ return vma_reader_restore_full(vmar, vmstate_fd, verbose, false, errp);
-+}
-+
-+int vma_reader_verify(VmaReader *vmar, bool verbose, Error **errp)
-+{
-+ guint8 dev_id;
-+
-+ for (dev_id = 1; dev_id < 255; dev_id++) {
-+ if (vma_reader_get_device_info(vmar, dev_id)) {
-+ allocate_rstate(vmar, dev_id, NULL, false);
-+ }
-+ }
-+
-+ return vma_reader_restore_full(vmar, -1, verbose, true, errp);
-+}
-+
-diff --git a/vma-writer.c b/vma-writer.c
-new file mode 100644
-index 0000000000..f5d2c5d23c
---- /dev/null
-+++ b/vma-writer.c
-@@ -0,0 +1,790 @@
-+/*
-+ * VMA: Virtual Machine Archive
-+ *
-+ * Copyright (C) 2012 Proxmox Server Solutions
-+ *
-+ * Authors:
-+ * Dietmar Maurer (dietmar@proxmox.com)
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ *
-+ */
-+
-+#include "qemu/osdep.h"
-+#include <glib.h>
-+#include <uuid/uuid.h>
-+
-+#include "vma.h"
-+#include "block/block.h"
-+#include "monitor/monitor.h"
-+#include "qemu/main-loop.h"
-+#include "qemu/coroutine.h"
-+#include "qemu/cutils.h"
-+
-+#define DEBUG_VMA 0
-+
-+#define DPRINTF(fmt, ...)\
-+ do { if (DEBUG_VMA) { printf("vma: " fmt, ## __VA_ARGS__); } } while (0)
-+
-+#define WRITE_BUFFERS 5
-+#define HEADER_CLUSTERS 8
-+#define HEADERBUF_SIZE (VMA_CLUSTER_SIZE*HEADER_CLUSTERS)
-+
-+struct VmaWriter {
-+ int fd;
-+ FILE *cmd;
-+ int status;
-+ char errmsg[8192];
-+ uuid_t uuid;
-+ bool header_written;
-+ bool closed;
-+
-+ /* we always write extents */
-+ unsigned char *outbuf;
-+ int outbuf_pos; /* in bytes */
-+ int outbuf_count; /* in VMA_BLOCKS */
-+ uint64_t outbuf_block_info[VMA_BLOCKS_PER_EXTENT];
-+
-+ unsigned char *headerbuf;
-+
-+ GChecksum *md5csum;
-+ CoMutex flush_lock;
-+ Coroutine *co_writer;
-+
-+ /* drive informations */
-+ VmaStreamInfo stream_info[256];
-+ guint stream_count;
-+
-+ guint8 vmstate_stream;
-+ uint32_t vmstate_clusters;
-+
-+ /* header blob table */
-+ char *header_blob_table;
-+ uint32_t header_blob_table_size;
-+ uint32_t header_blob_table_pos;
-+
-+ /* store for config blobs */
-+ uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
-+ uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
-+ uint32_t config_count;
-+};
-+
-+void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...)
-+{
-+ va_list ap;
-+
-+ if (vmaw->status < 0) {
-+ return;
-+ }
-+
-+ vmaw->status = -1;
-+
-+ va_start(ap, fmt);
-+ g_vsnprintf(vmaw->errmsg, sizeof(vmaw->errmsg), fmt, ap);
-+ va_end(ap);
-+
-+ DPRINTF("vma_writer_set_error: %s\n", vmaw->errmsg);
-+}
-+
-+static uint32_t allocate_header_blob(VmaWriter *vmaw, const char *data,
-+ size_t len)
-+{
-+ if (len > 65535) {
-+ return 0;
-+ }
-+
-+ if (!vmaw->header_blob_table ||
-+ (vmaw->header_blob_table_size <
-+ (vmaw->header_blob_table_pos + len + 2))) {
-+ int newsize = vmaw->header_blob_table_size + ((len + 2 + 511)/512)*512;
-+
-+ vmaw->header_blob_table = g_realloc(vmaw->header_blob_table, newsize);
-+ memset(vmaw->header_blob_table + vmaw->header_blob_table_size,
-+ 0, newsize - vmaw->header_blob_table_size);
-+ vmaw->header_blob_table_size = newsize;
-+ }
-+
-+ uint32_t cpos = vmaw->header_blob_table_pos;
-+ vmaw->header_blob_table[cpos] = len & 255;
-+ vmaw->header_blob_table[cpos+1] = (len >> 8) & 255;
-+ memcpy(vmaw->header_blob_table + cpos + 2, data, len);
-+ vmaw->header_blob_table_pos += len + 2;
-+ return cpos;
-+}
-+
-+static uint32_t allocate_header_string(VmaWriter *vmaw, const char *str)
-+{
-+ assert(vmaw);
-+
-+ size_t len = strlen(str) + 1;
-+
-+ return allocate_header_blob(vmaw, str, len);
-+}
-+
-+int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
-+ gsize len)
-+{
-+ assert(vmaw);
-+ assert(!vmaw->header_written);
-+ assert(vmaw->config_count < VMA_MAX_CONFIGS);
-+ assert(name);
-+ assert(data);
-+
-+ gchar *basename = g_path_get_basename(name);
-+ uint32_t name_ptr = allocate_header_string(vmaw, basename);
-+ g_free(basename);
-+
-+ if (!name_ptr) {
-+ return -1;
-+ }
-+
-+ uint32_t data_ptr = allocate_header_blob(vmaw, data, len);
-+ if (!data_ptr) {
-+ return -1;
-+ }
-+
-+ vmaw->config_names[vmaw->config_count] = name_ptr;
-+ vmaw->config_data[vmaw->config_count] = data_ptr;
-+
-+ vmaw->config_count++;
-+
-+ return 0;
-+}
-+
-+int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
-+ size_t size)
-+{
-+ assert(vmaw);
-+ assert(devname);
-+ assert(!vmaw->status);
-+
-+ if (vmaw->header_written) {
-+ vma_writer_set_error(vmaw, "vma_writer_register_stream: header "
-+ "already written");
-+ return -1;
-+ }
-+
-+ guint n = vmaw->stream_count + 1;
-+
-+ /* we can have dev_ids form 1 to 255 (0 reserved)
-+ * 255(-1) reseverd for safety
-+ */
-+ if (n > 254) {
-+ vma_writer_set_error(vmaw, "vma_writer_register_stream: "
-+ "too many drives");
-+ return -1;
-+ }
-+
-+ if (size <= 0) {
-+ vma_writer_set_error(vmaw, "vma_writer_register_stream: "
-+ "got strange size %zd", size);
-+ return -1;
-+ }
-+
-+ DPRINTF("vma_writer_register_stream %s %zu %d\n", devname, size, n);
-+
-+ vmaw->stream_info[n].devname = g_strdup(devname);
-+ vmaw->stream_info[n].size = size;
-+
-+ vmaw->stream_info[n].cluster_count = (size + VMA_CLUSTER_SIZE - 1) /
-+ VMA_CLUSTER_SIZE;
-+
-+ vmaw->stream_count = n;
-+
-+ if (strcmp(devname, "vmstate") == 0) {
-+ vmaw->vmstate_stream = n;
-+ }
-+
-+ return n;
-+}
-+
-+static void coroutine_fn yield_until_fd_writable(int fd)
-+{
-+ assert(qemu_in_coroutine());
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ aio_set_fd_handler(ctx, fd, false, NULL, (IOHandler *)qemu_coroutine_enter,
-+ NULL, qemu_coroutine_self());
-+ qemu_coroutine_yield();
-+ aio_set_fd_handler(ctx, fd, false, NULL, NULL, NULL, NULL);
-+}
-+
-+static ssize_t coroutine_fn
-+vma_queue_write(VmaWriter *vmaw, const void *buf, size_t bytes)
-+{
-+ DPRINTF("vma_queue_write enter %zd\n", bytes);
-+
-+ assert(vmaw);
-+ assert(buf);
-+ assert(bytes <= VMA_MAX_EXTENT_SIZE);
-+
-+ size_t done = 0;
-+ ssize_t ret;
-+
-+ assert(vmaw->co_writer == NULL);
-+
-+ vmaw->co_writer = qemu_coroutine_self();
-+
-+ while (done < bytes) {
-+ if (vmaw->status < 0) {
-+ DPRINTF("vma_queue_write detected canceled backup\n");
-+ done = -1;
-+ break;
-+ }
-+ yield_until_fd_writable(vmaw->fd);
-+ ret = write(vmaw->fd, buf + done, bytes - done);
-+ if (ret > 0) {
-+ done += ret;
-+ DPRINTF("vma_queue_write written %zd %zd\n", done, ret);
-+ } else if (ret < 0) {
-+ if (errno == EAGAIN || errno == EWOULDBLOCK) {
-+ /* try again */
-+ } else {
-+ vma_writer_set_error(vmaw, "vma_queue_write: write error - %s",
-+ g_strerror(errno));
-+ done = -1; /* always return failure for partial writes */
-+ break;
-+ }
-+ } else if (ret == 0) {
-+ /* should not happen - simply try again */
-+ }
-+ }
-+
-+ vmaw->co_writer = NULL;
-+
-+ return (done == bytes) ? bytes : -1;
-+}
-+
-+VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp)
-+{
-+ const char *p;
-+
-+ assert(sizeof(VmaHeader) == (4096 + 8192));
-+ assert(G_STRUCT_OFFSET(VmaHeader, config_names) == 2044);
-+ assert(G_STRUCT_OFFSET(VmaHeader, config_data) == 3068);
-+ assert(G_STRUCT_OFFSET(VmaHeader, dev_info) == 4096);
-+ assert(sizeof(VmaExtentHeader) == 512);
-+
-+ VmaWriter *vmaw = g_new0(VmaWriter, 1);
-+ vmaw->fd = -1;
-+
-+ vmaw->md5csum = g_checksum_new(G_CHECKSUM_MD5);
-+ if (!vmaw->md5csum) {
-+ error_setg(errp, "can't allocate cmsum\n");
-+ goto err;
-+ }
-+
-+ if (strstart(filename, "exec:", &p)) {
-+ vmaw->cmd = popen(p, "w");
-+ if (vmaw->cmd == NULL) {
-+ error_setg(errp, "can't popen command '%s' - %s\n", p,
-+ g_strerror(errno));
-+ goto err;
-+ }
-+ vmaw->fd = fileno(vmaw->cmd);
-+
-+ /* try to use O_NONBLOCK */
-+ fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
-+
-+ } else {
-+ struct stat st;
-+ int oflags;
-+ const char *tmp_id_str;
-+
-+ if ((stat(filename, &st) == 0) && S_ISFIFO(st.st_mode)) {
-+ oflags = O_NONBLOCK|O_WRONLY;
-+ vmaw->fd = qemu_open(filename, oflags, 0644);
-+ } else if (strstart(filename, "/dev/fdset/", &tmp_id_str)) {
-+ oflags = O_NONBLOCK|O_WRONLY;
-+ vmaw->fd = qemu_open(filename, oflags, 0644);
-+ } else if (strstart(filename, "/dev/fdname/", &tmp_id_str)) {
-+ vmaw->fd = monitor_get_fd(cur_mon, tmp_id_str, errp);
-+ if (vmaw->fd < 0) {
-+ goto err;
-+ }
-+ /* try to use O_NONBLOCK */
-+ fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
-+ } else {
-+ oflags = O_NONBLOCK|O_DIRECT|O_WRONLY|O_CREAT|O_EXCL;
-+ vmaw->fd = qemu_open(filename, oflags, 0644);
-+ }
-+
-+ if (vmaw->fd < 0) {
-+ error_setg(errp, "can't open file %s - %s\n", filename,
-+ g_strerror(errno));
-+ goto err;
-+ }
-+ }
-+
-+ /* we use O_DIRECT, so we need to align IO buffers */
-+
-+ vmaw->outbuf = qemu_memalign(512, VMA_MAX_EXTENT_SIZE);
-+ vmaw->headerbuf = qemu_memalign(512, HEADERBUF_SIZE);
-+
-+ vmaw->outbuf_count = 0;
-+ vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
-+
-+ vmaw->header_blob_table_pos = 1; /* start at pos 1 */
-+
-+ qemu_co_mutex_init(&vmaw->flush_lock);
-+
-+ uuid_copy(vmaw->uuid, uuid);
-+
-+ return vmaw;
-+
-+err:
-+ if (vmaw) {
-+ if (vmaw->cmd) {
-+ pclose(vmaw->cmd);
-+ } else if (vmaw->fd >= 0) {
-+ close(vmaw->fd);
-+ }
-+
-+ if (vmaw->md5csum) {
-+ g_checksum_free(vmaw->md5csum);
-+ }
-+
-+ g_free(vmaw);
-+ }
-+
-+ return NULL;
-+}
-+
-+static int coroutine_fn vma_write_header(VmaWriter *vmaw)
-+{
-+ assert(vmaw);
-+ unsigned char *buf = vmaw->headerbuf;
-+ VmaHeader *head = (VmaHeader *)buf;
-+
-+ int i;
-+
-+ DPRINTF("VMA WRITE HEADER\n");
-+
-+ if (vmaw->status < 0) {
-+ return vmaw->status;
-+ }
-+
-+ memset(buf, 0, HEADERBUF_SIZE);
-+
-+ head->magic = VMA_MAGIC;
-+ head->version = GUINT32_TO_BE(1); /* v1 */
-+ memcpy(head->uuid, vmaw->uuid, 16);
-+
-+ time_t ctime = time(NULL);
-+ head->ctime = GUINT64_TO_BE(ctime);
-+
-+ for (i = 0; i < VMA_MAX_CONFIGS; i++) {
-+ head->config_names[i] = GUINT32_TO_BE(vmaw->config_names[i]);
-+ head->config_data[i] = GUINT32_TO_BE(vmaw->config_data[i]);
-+ }
-+
-+ /* 32 bytes per device (12 used currently) = 8192 bytes max */
-+ for (i = 1; i <= 254; i++) {
-+ VmaStreamInfo *si = &vmaw->stream_info[i];
-+ if (si->size) {
-+ assert(si->devname);
-+ uint32_t devname_ptr = allocate_header_string(vmaw, si->devname);
-+ if (!devname_ptr) {
-+ return -1;
-+ }
-+ head->dev_info[i].devname_ptr = GUINT32_TO_BE(devname_ptr);
-+ head->dev_info[i].size = GUINT64_TO_BE(si->size);
-+ }
-+ }
-+
-+ uint32_t header_size = sizeof(VmaHeader) + vmaw->header_blob_table_size;
-+ head->header_size = GUINT32_TO_BE(header_size);
-+
-+ if (header_size > HEADERBUF_SIZE) {
-+ return -1; /* just to be sure */
-+ }
-+
-+ uint32_t blob_buffer_offset = sizeof(VmaHeader);
-+ memcpy(buf + blob_buffer_offset, vmaw->header_blob_table,
-+ vmaw->header_blob_table_size);
-+ head->blob_buffer_offset = GUINT32_TO_BE(blob_buffer_offset);
-+ head->blob_buffer_size = GUINT32_TO_BE(vmaw->header_blob_table_pos);
-+
-+ g_checksum_reset(vmaw->md5csum);
-+ g_checksum_update(vmaw->md5csum, (const guchar *)buf, header_size);
-+ gsize csize = 16;
-+ g_checksum_get_digest(vmaw->md5csum, (guint8 *)(head->md5sum), &csize);
-+
-+ return vma_queue_write(vmaw, buf, header_size);
-+}
-+
-+static int coroutine_fn vma_writer_flush(VmaWriter *vmaw)
-+{
-+ assert(vmaw);
-+
-+ int ret;
-+ int i;
-+
-+ if (vmaw->status < 0) {
-+ return vmaw->status;
-+ }
-+
-+ if (!vmaw->header_written) {
-+ vmaw->header_written = true;
-+ ret = vma_write_header(vmaw);
-+ if (ret < 0) {
-+ vma_writer_set_error(vmaw, "vma_writer_flush: write header failed");
-+ return ret;
-+ }
-+ }
-+
-+ DPRINTF("VMA WRITE FLUSH %d %d\n", vmaw->outbuf_count, vmaw->outbuf_pos);
-+
-+
-+ VmaExtentHeader *ehead = (VmaExtentHeader *)vmaw->outbuf;
-+
-+ ehead->magic = VMA_EXTENT_MAGIC;
-+ ehead->reserved1 = 0;
-+
-+ for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
-+ ehead->blockinfo[i] = GUINT64_TO_BE(vmaw->outbuf_block_info[i]);
-+ }
-+
-+ guint16 block_count = (vmaw->outbuf_pos - VMA_EXTENT_HEADER_SIZE) /
-+ VMA_BLOCK_SIZE;
-+
-+ ehead->block_count = GUINT16_TO_BE(block_count);
-+
-+ memcpy(ehead->uuid, vmaw->uuid, sizeof(ehead->uuid));
-+ memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
-+
-+ g_checksum_reset(vmaw->md5csum);
-+ g_checksum_update(vmaw->md5csum, vmaw->outbuf, VMA_EXTENT_HEADER_SIZE);
-+ gsize csize = 16;
-+ g_checksum_get_digest(vmaw->md5csum, ehead->md5sum, &csize);
-+
-+ int bytes = vmaw->outbuf_pos;
-+ ret = vma_queue_write(vmaw, vmaw->outbuf, bytes);
-+ if (ret != bytes) {
-+ vma_writer_set_error(vmaw, "vma_writer_flush: failed write");
-+ }
-+
-+ vmaw->outbuf_count = 0;
-+ vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
-+
-+ for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
-+ vmaw->outbuf_block_info[i] = 0;
-+ }
-+
-+ return vmaw->status;
-+}
-+
-+static int vma_count_open_streams(VmaWriter *vmaw)
-+{
-+ g_assert(vmaw != NULL);
-+
-+ int i;
-+ int open_drives = 0;
-+ for (i = 0; i <= 255; i++) {
-+ if (vmaw->stream_info[i].size && !vmaw->stream_info[i].finished) {
-+ open_drives++;
-+ }
-+ }
-+
-+ return open_drives;
-+}
-+
-+
-+/**
-+ * You need to call this if the vma archive does not contain
-+ * any data stream.
-+ */
-+int coroutine_fn
-+vma_writer_flush_output(VmaWriter *vmaw)
-+{
-+ qemu_co_mutex_lock(&vmaw->flush_lock);
-+ int ret = vma_writer_flush(vmaw);
-+ qemu_co_mutex_unlock(&vmaw->flush_lock);
-+ if (ret < 0) {
-+ vma_writer_set_error(vmaw, "vma_writer_flush_header failed");
-+ }
-+ return ret;
-+}
-+
-+/**
-+ * all jobs should call this when there is no more data
-+ * Returns: number of remaining stream (0 ==> finished)
-+ */
-+int coroutine_fn
-+vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id)
-+{
-+ g_assert(vmaw != NULL);
-+
-+ DPRINTF("vma_writer_set_status %d\n", dev_id);
-+ if (!vmaw->stream_info[dev_id].size) {
-+ vma_writer_set_error(vmaw, "vma_writer_close_stream: "
-+ "no such stream %d", dev_id);
-+ return -1;
-+ }
-+ if (vmaw->stream_info[dev_id].finished) {
-+ vma_writer_set_error(vmaw, "vma_writer_close_stream: "
-+ "stream already closed %d", dev_id);
-+ return -1;
-+ }
-+
-+ vmaw->stream_info[dev_id].finished = true;
-+
-+ int open_drives = vma_count_open_streams(vmaw);
-+
-+ if (open_drives <= 0) {
-+ DPRINTF("vma_writer_set_status all drives completed\n");
-+ vma_writer_flush_output(vmaw);
-+ }
-+
-+ return open_drives;
-+}
-+
-+int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status)
-+{
-+ int i;
-+
-+ g_assert(vmaw != NULL);
-+
-+ if (status) {
-+ status->status = vmaw->status;
-+ g_strlcpy(status->errmsg, vmaw->errmsg, sizeof(status->errmsg));
-+ for (i = 0; i <= 255; i++) {
-+ status->stream_info[i] = vmaw->stream_info[i];
-+ }
-+
-+ uuid_unparse_lower(vmaw->uuid, status->uuid_str);
-+ }
-+
-+ status->closed = vmaw->closed;
-+
-+ return vmaw->status;
-+}
-+
-+static int vma_writer_get_buffer(VmaWriter *vmaw)
-+{
-+ int ret = 0;
-+
-+ qemu_co_mutex_lock(&vmaw->flush_lock);
-+
-+ /* wait until buffer is available */
-+ while (vmaw->outbuf_count >= (VMA_BLOCKS_PER_EXTENT - 1)) {
-+ ret = vma_writer_flush(vmaw);
-+ if (ret < 0) {
-+ vma_writer_set_error(vmaw, "vma_writer_get_buffer: flush failed");
-+ break;
-+ }
-+ }
-+
-+ qemu_co_mutex_unlock(&vmaw->flush_lock);
-+
-+ return ret;
-+}
-+
-+
-+int64_t coroutine_fn
-+vma_writer_write(VmaWriter *vmaw, uint8_t dev_id, int64_t cluster_num,
-+ const unsigned char *buf, size_t *zero_bytes)
-+{
-+ g_assert(vmaw != NULL);
-+ g_assert(zero_bytes != NULL);
-+
-+ *zero_bytes = 0;
-+
-+ if (vmaw->status < 0) {
-+ return vmaw->status;
-+ }
-+
-+ if (!dev_id || !vmaw->stream_info[dev_id].size) {
-+ vma_writer_set_error(vmaw, "vma_writer_write: "
-+ "no such stream %d", dev_id);
-+ return -1;
-+ }
-+
-+ if (vmaw->stream_info[dev_id].finished) {
-+ vma_writer_set_error(vmaw, "vma_writer_write: "
-+ "stream already closed %d", dev_id);
-+ return -1;
-+ }
-+
-+
-+ if (cluster_num >= (((uint64_t)1)<<32)) {
-+ vma_writer_set_error(vmaw, "vma_writer_write: "
-+ "cluster number out of range");
-+ return -1;
-+ }
-+
-+ if (dev_id == vmaw->vmstate_stream) {
-+ if (cluster_num != vmaw->vmstate_clusters) {
-+ vma_writer_set_error(vmaw, "vma_writer_write: "
-+ "non sequential vmstate write");
-+ }
-+ vmaw->vmstate_clusters++;
-+ } else if (cluster_num >= vmaw->stream_info[dev_id].cluster_count) {
-+ vma_writer_set_error(vmaw, "vma_writer_write: cluster number too big");
-+ return -1;
-+ }
-+
-+ /* wait until buffer is available */
-+ if (vma_writer_get_buffer(vmaw) < 0) {
-+ vma_writer_set_error(vmaw, "vma_writer_write: "
-+ "vma_writer_get_buffer failed");
-+ return -1;
-+ }
-+
-+ DPRINTF("VMA WRITE %d %zd\n", dev_id, cluster_num);
-+
-+ uint64_t dev_size = vmaw->stream_info[dev_id].size;
-+ uint16_t mask = 0;
-+
-+ if (buf) {
-+ int i;
-+ int bit = 1;
-+ uint64_t byte_offset = cluster_num * VMA_CLUSTER_SIZE;
-+ for (i = 0; i < 16; i++) {
-+ const unsigned char *vmablock = buf + (i*VMA_BLOCK_SIZE);
-+
-+ // Note: If the source is not 64k-aligned, we might reach 4k blocks
-+ // after the end of the device. Always mark these as zero in the
-+ // mask, so the restore handles them correctly.
-+ if (byte_offset < dev_size &&
-+ !buffer_is_zero(vmablock, VMA_BLOCK_SIZE))
-+ {
-+ mask |= bit;
-+ memcpy(vmaw->outbuf + vmaw->outbuf_pos, vmablock,
-+ VMA_BLOCK_SIZE);
-+
-+ // prevent memory leakage on unaligned last block
-+ if (byte_offset + VMA_BLOCK_SIZE > dev_size) {
-+ uint64_t real_data_in_block = dev_size - byte_offset;
-+ memset(vmaw->outbuf + vmaw->outbuf_pos + real_data_in_block,
-+ 0, VMA_BLOCK_SIZE - real_data_in_block);
-+ }
-+
-+ vmaw->outbuf_pos += VMA_BLOCK_SIZE;
-+ } else {
-+ DPRINTF("VMA WRITE %zd ZERO BLOCK %d\n", cluster_num, i);
-+ vmaw->stream_info[dev_id].zero_bytes += VMA_BLOCK_SIZE;
-+ *zero_bytes += VMA_BLOCK_SIZE;
-+ }
-+
-+ byte_offset += VMA_BLOCK_SIZE;
-+ bit = bit << 1;
-+ }
-+ } else {
-+ DPRINTF("VMA WRITE %zd ZERO CLUSTER\n", cluster_num);
-+ vmaw->stream_info[dev_id].zero_bytes += VMA_CLUSTER_SIZE;
-+ *zero_bytes += VMA_CLUSTER_SIZE;
-+ }
-+
-+ uint64_t block_info = ((uint64_t)mask) << (32+16);
-+ block_info |= ((uint64_t)dev_id) << 32;
-+ block_info |= (cluster_num & 0xffffffff);
-+ vmaw->outbuf_block_info[vmaw->outbuf_count] = block_info;
-+
-+ DPRINTF("VMA WRITE MASK %zd %zx\n", cluster_num, block_info);
-+
-+ vmaw->outbuf_count++;
-+
-+ /** NOTE: We allways write whole clusters, but we correctly set
-+ * transferred bytes. So transferred == size when when everything
-+ * went OK.
-+ */
-+ size_t transferred = VMA_CLUSTER_SIZE;
-+
-+ if (dev_id != vmaw->vmstate_stream) {
-+ uint64_t last = (cluster_num + 1) * VMA_CLUSTER_SIZE;
-+ if (last > dev_size) {
-+ uint64_t diff = last - dev_size;
-+ if (diff >= VMA_CLUSTER_SIZE) {
-+ vma_writer_set_error(vmaw, "vma_writer_write: "
-+ "read after last cluster");
-+ return -1;
-+ }
-+ transferred -= diff;
-+ }
-+ }
-+
-+ vmaw->stream_info[dev_id].transferred += transferred;
-+
-+ return transferred;
-+}
-+
-+void vma_writer_error_propagate(VmaWriter *vmaw, Error **errp)
-+{
-+ if (vmaw->status < 0 && *errp == NULL) {
-+ error_setg(errp, "%s", vmaw->errmsg);
-+ }
-+}
-+
-+int vma_writer_close(VmaWriter *vmaw, Error **errp)
-+{
-+ g_assert(vmaw != NULL);
-+
-+ int i;
-+
-+ qemu_co_mutex_lock(&vmaw->flush_lock); // wait for pending writes
-+
-+ assert(vmaw->co_writer == NULL);
-+
-+ if (vmaw->cmd) {
-+ if (pclose(vmaw->cmd) < 0) {
-+ vma_writer_set_error(vmaw, "vma_writer_close: "
-+ "pclose failed - %s", g_strerror(errno));
-+ }
-+ } else {
-+ if (close(vmaw->fd) < 0) {
-+ vma_writer_set_error(vmaw, "vma_writer_close: "
-+ "close failed - %s", g_strerror(errno));
-+ }
-+ }
-+
-+ for (i = 0; i <= 255; i++) {
-+ VmaStreamInfo *si = &vmaw->stream_info[i];
-+ if (si->size) {
-+ if (!si->finished) {
-+ vma_writer_set_error(vmaw, "vma_writer_close: "
-+ "detected open stream '%s'", si->devname);
-+ } else if ((si->transferred != si->size) &&
-+ (i != vmaw->vmstate_stream)) {
-+ vma_writer_set_error(vmaw, "vma_writer_close: "
-+ "incomplete stream '%s' (%zd != %zd)",
-+ si->devname, si->transferred, si->size);
-+ }
-+ }
-+ }
-+
-+ for (i = 0; i <= 255; i++) {
-+ vmaw->stream_info[i].finished = 1; /* mark as closed */
-+ }
-+
-+ vmaw->closed = 1;
-+
-+ if (vmaw->status < 0 && *errp == NULL) {
-+ error_setg(errp, "%s", vmaw->errmsg);
-+ }
-+
-+ qemu_co_mutex_unlock(&vmaw->flush_lock);
-+
-+ return vmaw->status;
-+}
-+
-+void vma_writer_destroy(VmaWriter *vmaw)
-+{
-+ assert(vmaw);
-+
-+ int i;
-+
-+ for (i = 0; i <= 255; i++) {
-+ if (vmaw->stream_info[i].devname) {
-+ g_free(vmaw->stream_info[i].devname);
-+ }
-+ }
-+
-+ if (vmaw->md5csum) {
-+ g_checksum_free(vmaw->md5csum);
-+ }
-+
-+ qemu_vfree(vmaw->headerbuf);
-+ qemu_vfree(vmaw->outbuf);
-+ g_free(vmaw);
-+}
-diff --git a/vma.c b/vma.c
-new file mode 100644
-index 0000000000..2eea2fc281
---- /dev/null
-+++ b/vma.c
-@@ -0,0 +1,839 @@
-+/*
-+ * VMA: Virtual Machine Archive
-+ *
-+ * Copyright (C) 2012-2013 Proxmox Server Solutions
-+ *
-+ * Authors:
-+ * Dietmar Maurer (dietmar@proxmox.com)
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ *
-+ */
-+
-+#include "qemu/osdep.h"
-+#include <glib.h>
-+
-+#include "vma.h"
-+#include "qemu-common.h"
-+#include "qemu/module.h"
-+#include "qemu/error-report.h"
-+#include "qemu/main-loop.h"
-+#include "qemu/cutils.h"
-+#include "qapi/qmp/qdict.h"
-+#include "sysemu/block-backend.h"
-+
-+static void help(void)
-+{
-+ const char *help_msg =
-+ "usage: vma command [command options]\n"
-+ "\n"
-+ "vma list <filename>\n"
-+ "vma config <filename> [-c config]\n"
-+ "vma create <filename> [-c config] pathname ...\n"
-+ "vma extract <filename> [-r <fifo>] <targetdir>\n"
-+ "vma verify <filename> [-v]\n"
-+ ;
-+
-+ printf("%s", help_msg);
-+ exit(1);
-+}
-+
-+static const char *extract_devname(const char *path, char **devname, int index)
-+{
-+ assert(path);
-+
-+ const char *sep = strchr(path, '=');
-+
-+ if (sep) {
-+ *devname = g_strndup(path, sep - path);
-+ path = sep + 1;
-+ } else {
-+ if (index >= 0) {
-+ *devname = g_strdup_printf("disk%d", index);
-+ } else {
-+ *devname = NULL;
-+ }
-+ }
-+
-+ return path;
-+}
-+
-+static void print_content(VmaReader *vmar)
-+{
-+ assert(vmar);
-+
-+ VmaHeader *head = vma_reader_get_header(vmar);
-+
-+ GList *l = vma_reader_get_config_data(vmar);
-+ while (l && l->data) {
-+ VmaConfigData *cdata = (VmaConfigData *)l->data;
-+ l = g_list_next(l);
-+ printf("CFG: size: %d name: %s\n", cdata->len, cdata->name);
-+ }
-+
-+ int i;
-+ VmaDeviceInfo *di;
-+ for (i = 1; i < 255; i++) {
-+ di = vma_reader_get_device_info(vmar, i);
-+ if (di) {
-+ if (strcmp(di->devname, "vmstate") == 0) {
-+ printf("VMSTATE: dev_id=%d memory: %zd\n", i, di->size);
-+ } else {
-+ printf("DEV: dev_id=%d size: %zd devname: %s\n",
-+ i, di->size, di->devname);
-+ }
-+ }
-+ }
-+ /* ctime is the last entry we print */
-+ printf("CTIME: %s", ctime(&head->ctime));
-+ fflush(stdout);
-+}
-+
-+static int list_content(int argc, char **argv)
-+{
-+ int c, ret = 0;
-+ const char *filename;
-+
-+ for (;;) {
-+ c = getopt(argc, argv, "h");
-+ if (c == -1) {
-+ break;
-+ }
-+ switch (c) {
-+ case '?':
-+ case 'h':
-+ help();
-+ break;
-+ default:
-+ g_assert_not_reached();
-+ }
-+ }
-+
-+ /* Get the filename */
-+ if ((optind + 1) != argc) {
-+ help();
-+ }
-+ filename = argv[optind++];
-+
-+ Error *errp = NULL;
-+ VmaReader *vmar = vma_reader_create(filename, &errp);
-+
-+ if (!vmar) {
-+ g_error("%s", error_get_pretty(errp));
-+ }
-+
-+ print_content(vmar);
-+
-+ vma_reader_destroy(vmar);
-+
-+ return ret;
-+}
-+
-+typedef struct RestoreMap {
-+ char *devname;
-+ char *path;
-+ char *format;
-+ uint64_t throttling_bps;
-+ char *throttling_group;
-+ char *cache;
-+ bool write_zero;
-+} RestoreMap;
-+
-+static bool try_parse_option(char **line, const char *optname, char **out, const char *inbuf) {
-+ size_t optlen = strlen(optname);
-+ if (strncmp(*line, optname, optlen) != 0 || (*line)[optlen] != '=') {
-+ return false;
-+ }
-+ if (*out) {
-+ g_error("read map failed - duplicate value for option '%s'", optname);
-+ }
-+ char *value = (*line) + optlen + 1; /* including a '=' */
-+ char *colon = strchr(value, ':');
-+ if (!colon) {
-+ g_error("read map failed - option '%s' not terminated ('%s')",
-+ optname, inbuf);
-+ }
-+ *line = colon+1;
-+ *out = g_strndup(value, colon - value);
-+ return true;
-+}
-+
-+static uint64_t verify_u64(const char *text) {
-+ uint64_t value;
-+ const char *endptr = NULL;
-+ if (qemu_strtou64(text, &endptr, 0, &value) != 0 || !endptr || *endptr) {
-+ g_error("read map failed - not a number: %s", text);
-+ }
-+ return value;
-+}
-+
-+static int extract_content(int argc, char **argv)
-+{
-+ int c, ret = 0;
-+ int verbose = 0;
-+ const char *filename;
-+ const char *dirname;
-+ const char *readmap = NULL;
-+
-+ for (;;) {
-+ c = getopt(argc, argv, "hvr:");
-+ if (c == -1) {
-+ break;
-+ }
-+ switch (c) {
-+ case '?':
-+ case 'h':
-+ help();
-+ break;
-+ case 'r':
-+ readmap = optarg;
-+ break;
-+ case 'v':
-+ verbose = 1;
-+ break;
-+ default:
-+ help();
-+ }
-+ }
-+
-+ /* Get the filename */
-+ if ((optind + 2) != argc) {
-+ help();
-+ }
-+ filename = argv[optind++];
-+ dirname = argv[optind++];
-+
-+ Error *errp = NULL;
-+ VmaReader *vmar = vma_reader_create(filename, &errp);
-+
-+ if (!vmar) {
-+ g_error("%s", error_get_pretty(errp));
-+ }
-+
-+ if (mkdir(dirname, 0777) < 0) {
-+ g_error("unable to create target directory %s - %s",
-+ dirname, g_strerror(errno));
-+ }
-+
-+ GList *l = vma_reader_get_config_data(vmar);
-+ while (l && l->data) {
-+ VmaConfigData *cdata = (VmaConfigData *)l->data;
-+ l = g_list_next(l);
-+ char *cfgfn = g_strdup_printf("%s/%s", dirname, cdata->name);
-+ GError *err = NULL;
-+ if (!g_file_set_contents(cfgfn, (gchar *)cdata->data, cdata->len,
-+ &err)) {
-+ g_error("unable to write file: %s", err->message);
-+ }
-+ }
-+
-+ GHashTable *devmap = g_hash_table_new(g_str_hash, g_str_equal);
-+
-+ if (readmap) {
-+ print_content(vmar);
-+
-+ FILE *map = fopen(readmap, "r");
-+ if (!map) {
-+ g_error("unable to open fifo %s - %s", readmap, g_strerror(errno));
-+ }
-+
-+ while (1) {
-+ char inbuf[8192];
-+ char *line = fgets(inbuf, sizeof(inbuf), map);
-+ char *format = NULL;
-+ char *bps = NULL;
-+ char *group = NULL;
-+ char *cache = NULL;
-+ if (!line || line[0] == '\0' || !strcmp(line, "done\n")) {
-+ break;
-+ }
-+ int len = strlen(line);
-+ if (line[len - 1] == '\n') {
-+ line[len - 1] = '\0';
-+ if (len == 1) {
-+ break;
-+ }
-+ }
-+
-+ while (1) {
-+ if (!try_parse_option(&line, "format", &format, inbuf) &&
-+ !try_parse_option(&line, "throttling.bps", &bps, inbuf) &&
-+ !try_parse_option(&line, "throttling.group", &group, inbuf) &&
-+ !try_parse_option(&line, "cache", &cache, inbuf))
-+ {
-+ break;
-+ }
-+ }
-+
-+ uint64_t bps_value = 0;
-+ if (bps) {
-+ bps_value = verify_u64(bps);
-+ g_free(bps);
-+ }
-+
-+ const char *path;
-+ bool write_zero;
-+ if (line[0] == '0' && line[1] == ':') {
-+ path = line + 2;
-+ write_zero = false;
-+ } else if (line[0] == '1' && line[1] == ':') {
-+ path = line + 2;
-+ write_zero = true;
-+ } else {
-+ g_error("read map failed - parse error ('%s')", inbuf);
-+ }
-+
-+ char *devname = NULL;
-+ path = extract_devname(path, &devname, -1);
-+ if (!devname) {
-+ g_error("read map failed - no dev name specified ('%s')",
-+ inbuf);
-+ }
-+
-+ RestoreMap *map = g_new0(RestoreMap, 1);
-+ map->devname = g_strdup(devname);
-+ map->path = g_strdup(path);
-+ map->format = format;
-+ map->throttling_bps = bps_value;
-+ map->throttling_group = group;
-+ map->cache = cache;
-+ map->write_zero = write_zero;
-+
-+ g_hash_table_insert(devmap, map->devname, map);
-+
-+ };
-+ }
-+
-+ int i;
-+ int vmstate_fd = -1;
-+ guint8 vmstate_stream = 0;
-+
-+ BlockBackend *blk = NULL;
-+
-+ for (i = 1; i < 255; i++) {
-+ VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
-+ if (di && (strcmp(di->devname, "vmstate") == 0)) {
-+ vmstate_stream = i;
-+ char *statefn = g_strdup_printf("%s/vmstate.bin", dirname);
-+ vmstate_fd = open(statefn, O_WRONLY|O_CREAT|O_EXCL, 0644);
-+ if (vmstate_fd < 0) {
-+ g_error("create vmstate file '%s' failed - %s", statefn,
-+ g_strerror(errno));
-+ }
-+ g_free(statefn);
-+ } else if (di) {
-+ char *devfn = NULL;
-+ const char *format = NULL;
-+ uint64_t throttling_bps = 0;
-+ const char *throttling_group = NULL;
-+ const char *cache = NULL;
-+ int flags = BDRV_O_RDWR;
-+ bool write_zero = true;
-+
-+ if (readmap) {
-+ RestoreMap *map;
-+ map = (RestoreMap *)g_hash_table_lookup(devmap, di->devname);
-+ if (map == NULL) {
-+ g_error("no device name mapping for %s", di->devname);
-+ }
-+ devfn = map->path;
-+ format = map->format;
-+ throttling_bps = map->throttling_bps;
-+ throttling_group = map->throttling_group;
-+ cache = map->cache;
-+ write_zero = map->write_zero;
-+ } else {
-+ devfn = g_strdup_printf("%s/tmp-disk-%s.raw",
-+ dirname, di->devname);
-+ printf("DEVINFO %s %zd\n", devfn, di->size);
-+
-+ bdrv_img_create(devfn, "raw", NULL, NULL, NULL, di->size,
-+ flags, true, &errp);
-+ if (errp) {
-+ g_error("can't create file %s: %s", devfn,
-+ error_get_pretty(errp));
-+ }
-+
-+ /* Note: we created an empty file above, so there is no
-+ * need to write zeroes (so we generate a sparse file)
-+ */
-+ write_zero = false;
-+ }
-+
-+ size_t devlen = strlen(devfn);
-+ QDict *options = NULL;
-+ bool writethrough;
-+ if (format) {
-+ /* explicit format from commandline */
-+ options = qdict_new();
-+ qdict_put_str(options, "driver", format);
-+ } else if ((devlen > 4 && strcmp(devfn+devlen-4, ".raw") == 0) ||
-+ strncmp(devfn, "/dev/", 5) == 0)
-+ {
-+ /* This part is now deprecated for PVE as well (just as qemu
-+ * deprecated not specifying an explicit raw format, too.
-+ */
-+ /* explicit raw format */
-+ options = qdict_new();
-+ qdict_put_str(options, "driver", "raw");
-+ }
-+ if (cache && bdrv_parse_cache_mode(cache, &flags, &writethrough)) {
-+ g_error("invalid cache option: %s\n", cache);
-+ }
-+
-+ if (errp || !(blk = blk_new_open(devfn, NULL, options, flags, &errp))) {
-+ g_error("can't open file %s - %s", devfn,
-+ error_get_pretty(errp));
-+ }
-+
-+ if (cache) {
-+ blk_set_enable_write_cache(blk, !writethrough);
-+ }
-+
-+ if (throttling_group) {
-+ blk_io_limits_enable(blk, throttling_group);
-+ }
-+
-+ if (throttling_bps) {
-+ if (!throttling_group) {
-+ blk_io_limits_enable(blk, devfn);
-+ }
-+
-+ ThrottleConfig cfg;
-+ throttle_config_init(&cfg);
-+ cfg.buckets[THROTTLE_BPS_WRITE].avg = throttling_bps;
-+ Error *err = NULL;
-+ if (!throttle_is_valid(&cfg, &err)) {
-+ error_report_err(err);
-+ g_error("failed to apply throttling");
-+ }
-+ blk_set_io_limits(blk, &cfg);
-+ }
-+
-+ if (vma_reader_register_bs(vmar, i, blk, write_zero, &errp) < 0) {
-+ g_error("%s", error_get_pretty(errp));
-+ }
-+
-+ if (!readmap) {
-+ g_free(devfn);
-+ }
-+ }
-+ }
-+
-+ if (vma_reader_restore(vmar, vmstate_fd, verbose, &errp) < 0) {
-+ g_error("restore failed - %s", error_get_pretty(errp));
-+ }
-+
-+ if (!readmap) {
-+ for (i = 1; i < 255; i++) {
-+ VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
-+ if (di && (i != vmstate_stream)) {
-+ char *tmpfn = g_strdup_printf("%s/tmp-disk-%s.raw",
-+ dirname, di->devname);
-+ char *fn = g_strdup_printf("%s/disk-%s.raw",
-+ dirname, di->devname);
-+ if (rename(tmpfn, fn) != 0) {
-+ g_error("rename %s to %s failed - %s",
-+ tmpfn, fn, g_strerror(errno));
-+ }
-+ }
-+ }
-+ }
-+
-+ vma_reader_destroy(vmar);
-+
-+ blk_unref(blk);
-+
-+ bdrv_close_all();
-+
-+ return ret;
-+}
-+
-+static int verify_content(int argc, char **argv)
-+{
-+ int c, ret = 0;
-+ int verbose = 0;
-+ const char *filename;
-+
-+ for (;;) {
-+ c = getopt(argc, argv, "hv");
-+ if (c == -1) {
-+ break;
-+ }
-+ switch (c) {
-+ case '?':
-+ case 'h':
-+ help();
-+ break;
-+ case 'v':
-+ verbose = 1;
-+ break;
-+ default:
-+ help();
-+ }
-+ }
-+
-+ /* Get the filename */
-+ if ((optind + 1) != argc) {
-+ help();
-+ }
-+ filename = argv[optind++];
-+
-+ Error *errp = NULL;
-+ VmaReader *vmar = vma_reader_create(filename, &errp);
-+
-+ if (!vmar) {
-+ g_error("%s", error_get_pretty(errp));
-+ }
-+
-+ if (verbose) {
-+ print_content(vmar);
-+ }
-+
-+ if (vma_reader_verify(vmar, verbose, &errp) < 0) {
-+ g_error("verify failed - %s", error_get_pretty(errp));
-+ }
-+
-+ vma_reader_destroy(vmar);
-+
-+ bdrv_close_all();
-+
-+ return ret;
-+}
-+
-+typedef struct BackupJob {
-+ BlockBackend *target;
-+ int64_t len;
-+ VmaWriter *vmaw;
-+ uint8_t dev_id;
-+} BackupJob;
-+
-+#define BACKUP_SECTORS_PER_CLUSTER (VMA_CLUSTER_SIZE / BDRV_SECTOR_SIZE)
-+
-+static void coroutine_fn backup_run_empty(void *opaque)
-+{
-+ VmaWriter *vmaw = (VmaWriter *)opaque;
-+
-+ vma_writer_flush_output(vmaw);
-+
-+ Error *err = NULL;
-+ if (vma_writer_close(vmaw, &err) != 0) {
-+ g_warning("vma_writer_close failed %s", error_get_pretty(err));
-+ }
-+}
-+
-+static void coroutine_fn backup_run(void *opaque)
-+{
-+ BackupJob *job = (BackupJob *)opaque;
-+ struct iovec iov;
-+ QEMUIOVector qiov;
-+
-+ int64_t start, end;
-+ int ret = 0;
-+
-+ unsigned char *buf = blk_blockalign(job->target, VMA_CLUSTER_SIZE);
-+
-+ start = 0;
-+ end = DIV_ROUND_UP(job->len / BDRV_SECTOR_SIZE,
-+ BACKUP_SECTORS_PER_CLUSTER);
-+
-+ for (; start < end; start++) {
-+ iov.iov_base = buf;
-+ iov.iov_len = VMA_CLUSTER_SIZE;
-+ qemu_iovec_init_external(&qiov, &iov, 1);
-+
-+ ret = blk_co_preadv(job->target, start * VMA_CLUSTER_SIZE,
-+ VMA_CLUSTER_SIZE, &qiov, 0);
-+ if (ret < 0) {
-+ vma_writer_set_error(job->vmaw, "read error", -1);
-+ goto out;
-+ }
-+
-+ size_t zb = 0;
-+ if (vma_writer_write(job->vmaw, job->dev_id, start, buf, &zb) < 0) {
-+ vma_writer_set_error(job->vmaw, "backup_dump_cb vma_writer_write failed", -1);
-+ goto out;
-+ }
-+ }
-+
-+
-+out:
-+ if (vma_writer_close_stream(job->vmaw, job->dev_id) <= 0) {
-+ Error *err = NULL;
-+ if (vma_writer_close(job->vmaw, &err) != 0) {
-+ g_warning("vma_writer_close failed %s", error_get_pretty(err));
-+ }
-+ }
-+ qemu_vfree(buf);
-+}
-+
-+static int create_archive(int argc, char **argv)
-+{
-+ int i, c;
-+ int verbose = 0;
-+ const char *archivename;
-+ GList *config_files = NULL;
-+
-+ for (;;) {
-+ c = getopt(argc, argv, "hvc:");
-+ if (c == -1) {
-+ break;
-+ }
-+ switch (c) {
-+ case '?':
-+ case 'h':
-+ help();
-+ break;
-+ case 'c':
-+ config_files = g_list_append(config_files, optarg);
-+ break;
-+ case 'v':
-+ verbose = 1;
-+ break;
-+ default:
-+ g_assert_not_reached();
-+ }
-+ }
-+
-+
-+ /* make sure we an archive name */
-+ if ((optind + 1) > argc) {
-+ help();
-+ }
-+
-+ archivename = argv[optind++];
-+
-+ uuid_t uuid;
-+ uuid_generate(uuid);
-+
-+ Error *local_err = NULL;
-+ VmaWriter *vmaw = vma_writer_create(archivename, uuid, &local_err);
-+
-+ if (vmaw == NULL) {
-+ g_error("%s", error_get_pretty(local_err));
-+ }
-+
-+ GList *l = config_files;
-+ while (l && l->data) {
-+ char *name = l->data;
-+ char *cdata = NULL;
-+ gsize clen = 0;
-+ GError *err = NULL;
-+ if (!g_file_get_contents(name, &cdata, &clen, &err)) {
-+ unlink(archivename);
-+ g_error("Unable to read file: %s", err->message);
-+ }
-+
-+ if (vma_writer_add_config(vmaw, name, cdata, clen) != 0) {
-+ unlink(archivename);
-+ g_error("Unable to append config data %s (len = %zd)",
-+ name, clen);
-+ }
-+ l = g_list_next(l);
-+ }
-+
-+ int devcount = 0;
-+ while (optind < argc) {
-+ const char *path = argv[optind++];
-+ char *devname = NULL;
-+ path = extract_devname(path, &devname, devcount++);
-+
-+ Error *errp = NULL;
-+ BlockBackend *target;
-+
-+ target = blk_new_open(path, NULL, NULL, 0, &errp);
-+ if (!target) {
-+ unlink(archivename);
-+ g_error("bdrv_open '%s' failed - %s", path, error_get_pretty(errp));
-+ }
-+ int64_t size = blk_getlength(target);
-+ int dev_id = vma_writer_register_stream(vmaw, devname, size);
-+ if (dev_id <= 0) {
-+ unlink(archivename);
-+ g_error("vma_writer_register_stream '%s' failed", devname);
-+ }
-+
-+ BackupJob *job = g_new0(BackupJob, 1);
-+ job->len = size;
-+ job->target = target;
-+ job->vmaw = vmaw;
-+ job->dev_id = dev_id;
-+
-+ Coroutine *co = qemu_coroutine_create(backup_run, job);
-+ qemu_coroutine_enter(co);
-+ }
-+
-+ VmaStatus vmastat;
-+ int percent = 0;
-+ int last_percent = -1;
-+
-+ if (devcount) {
-+ while (1) {
-+ main_loop_wait(false);
-+ vma_writer_get_status(vmaw, &vmastat);
-+
-+ if (verbose) {
-+
-+ uint64_t total = 0;
-+ uint64_t transferred = 0;
-+ uint64_t zero_bytes = 0;
-+
-+ int i;
-+ for (i = 0; i < 256; i++) {
-+ if (vmastat.stream_info[i].size) {
-+ total += vmastat.stream_info[i].size;
-+ transferred += vmastat.stream_info[i].transferred;
-+ zero_bytes += vmastat.stream_info[i].zero_bytes;
-+ }
-+ }
-+ percent = (transferred*100)/total;
-+ if (percent != last_percent) {
-+ fprintf(stderr, "progress %d%% %zd/%zd %zd\n", percent,
-+ transferred, total, zero_bytes);
-+ fflush(stderr);
-+
-+ last_percent = percent;
-+ }
-+ }
-+
-+ if (vmastat.closed) {
-+ break;
-+ }
-+ }
-+ } else {
-+ Coroutine *co = qemu_coroutine_create(backup_run_empty, vmaw);
-+ qemu_coroutine_enter(co);
-+ while (1) {
-+ main_loop_wait(false);
-+ vma_writer_get_status(vmaw, &vmastat);
-+ if (vmastat.closed) {
-+ break;
-+ }
-+ }
-+ }
-+
-+ bdrv_drain_all();
-+
-+ vma_writer_get_status(vmaw, &vmastat);
-+
-+ if (verbose) {
-+ for (i = 0; i < 256; i++) {
-+ VmaStreamInfo *si = &vmastat.stream_info[i];
-+ if (si->size) {
-+ fprintf(stderr, "image %s: size=%zd zeros=%zd saved=%zd\n",
-+ si->devname, si->size, si->zero_bytes,
-+ si->size - si->zero_bytes);
-+ }
-+ }
-+ }
-+
-+ if (vmastat.status < 0) {
-+ unlink(archivename);
-+ g_error("creating vma archive failed");
-+ }
-+
-+ vma_writer_destroy(vmaw);
-+ return 0;
-+}
-+
-+static int dump_config(int argc, char **argv)
-+{
-+ int c, ret = 0;
-+ const char *filename;
-+ const char *config_name = "qemu-server.conf";
-+
-+ for (;;) {
-+ c = getopt(argc, argv, "hc:");
-+ if (c == -1) {
-+ break;
-+ }
-+ switch (c) {
-+ case '?':
-+ case 'h':
-+ help();
-+ break;
-+ case 'c':
-+ config_name = optarg;
-+ break;
-+ default:
-+ help();
-+ }
-+ }
-+
-+ /* Get the filename */
-+ if ((optind + 1) != argc) {
-+ help();
-+ }
-+ filename = argv[optind++];
-+
-+ Error *errp = NULL;
-+ VmaReader *vmar = vma_reader_create(filename, &errp);
-+
-+ if (!vmar) {
-+ g_error("%s", error_get_pretty(errp));
-+ }
-+
-+ int found = 0;
-+ GList *l = vma_reader_get_config_data(vmar);
-+ while (l && l->data) {
-+ VmaConfigData *cdata = (VmaConfigData *)l->data;
-+ l = g_list_next(l);
-+ if (strcmp(cdata->name, config_name) == 0) {
-+ found = 1;
-+ fwrite(cdata->data, cdata->len, 1, stdout);
-+ break;
-+ }
-+ }
-+
-+ vma_reader_destroy(vmar);
-+
-+ bdrv_close_all();
-+
-+ if (!found) {
-+ fprintf(stderr, "unable to find configuration data '%s'\n", config_name);
-+ return -1;
-+ }
-+
-+ return ret;
-+}
-+
-+int main(int argc, char **argv)
-+{
-+ const char *cmdname;
-+ Error *main_loop_err = NULL;
-+
-+ error_init(argv[0]);
-+ module_call_init(MODULE_INIT_TRACE);
-+ qemu_init_exec_dir(argv[0]);
-+
-+ if (qemu_init_main_loop(&main_loop_err)) {
-+ g_error("%s", error_get_pretty(main_loop_err));
-+ }
-+
-+ bdrv_init();
-+ module_call_init(MODULE_INIT_QOM);
-+
-+ if (argc < 2) {
-+ help();
-+ }
-+
-+ cmdname = argv[1];
-+ argc--; argv++;
-+
-+
-+ if (!strcmp(cmdname, "list")) {
-+ return list_content(argc, argv);
-+ } else if (!strcmp(cmdname, "create")) {
-+ return create_archive(argc, argv);
-+ } else if (!strcmp(cmdname, "extract")) {
-+ return extract_content(argc, argv);
-+ } else if (!strcmp(cmdname, "verify")) {
-+ return verify_content(argc, argv);
-+ } else if (!strcmp(cmdname, "config")) {
-+ return dump_config(argc, argv);
-+ }
-+
-+ help();
-+ return 0;
-+}
-diff --git a/vma.h b/vma.h
-new file mode 100644
-index 0000000000..c895c97f6d
---- /dev/null
-+++ b/vma.h
-@@ -0,0 +1,150 @@
-+/*
-+ * VMA: Virtual Machine Archive
-+ *
-+ * Copyright (C) Proxmox Server Solutions
-+ *
-+ * Authors:
-+ * Dietmar Maurer (dietmar@proxmox.com)
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ *
-+ */
-+
-+#ifndef BACKUP_VMA_H
-+#define BACKUP_VMA_H
-+
-+#include <uuid/uuid.h>
-+#include "qapi/error.h"
-+#include "block/block.h"
-+
-+#define VMA_BLOCK_BITS 12
-+#define VMA_BLOCK_SIZE (1<<VMA_BLOCK_BITS)
-+#define VMA_CLUSTER_BITS (VMA_BLOCK_BITS+4)
-+#define VMA_CLUSTER_SIZE (1<<VMA_CLUSTER_BITS)
-+
-+#if VMA_CLUSTER_SIZE != 65536
-+#error unexpected cluster size
-+#endif
-+
-+#define VMA_EXTENT_HEADER_SIZE 512
-+#define VMA_BLOCKS_PER_EXTENT 59
-+#define VMA_MAX_CONFIGS 256
-+
-+#define VMA_MAX_EXTENT_SIZE \
-+ (VMA_EXTENT_HEADER_SIZE+VMA_CLUSTER_SIZE*VMA_BLOCKS_PER_EXTENT)
-+#if VMA_MAX_EXTENT_SIZE != 3867136
-+#error unexpected VMA_EXTENT_SIZE
-+#endif
-+
-+/* File Format Definitions */
-+
-+#define VMA_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|0x00))
-+#define VMA_EXTENT_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|'E'))
-+
-+typedef struct VmaDeviceInfoHeader {
-+ uint32_t devname_ptr; /* offset into blob_buffer table */
-+ uint32_t reserved0;
-+ uint64_t size; /* device size in bytes */
-+ uint64_t reserved1;
-+ uint64_t reserved2;
-+} VmaDeviceInfoHeader;
-+
-+typedef struct VmaHeader {
-+ uint32_t magic;
-+ uint32_t version;
-+ unsigned char uuid[16];
-+ int64_t ctime;
-+ unsigned char md5sum[16];
-+
-+ uint32_t blob_buffer_offset;
-+ uint32_t blob_buffer_size;
-+ uint32_t header_size;
-+
-+ unsigned char reserved[1984];
-+
-+ uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
-+ uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
-+
-+ uint32_t reserved1;
-+
-+ VmaDeviceInfoHeader dev_info[256];
-+} VmaHeader;
-+
-+typedef struct VmaExtentHeader {
-+ uint32_t magic;
-+ uint16_t reserved1;
-+ uint16_t block_count;
-+ unsigned char uuid[16];
-+ unsigned char md5sum[16];
-+ uint64_t blockinfo[VMA_BLOCKS_PER_EXTENT];
-+} VmaExtentHeader;
-+
-+/* functions/definitions to read/write vma files */
-+
-+typedef struct VmaReader VmaReader;
-+
-+typedef struct VmaWriter VmaWriter;
-+
-+typedef struct VmaConfigData {
-+ const char *name;
-+ const void *data;
-+ uint32_t len;
-+} VmaConfigData;
-+
-+typedef struct VmaStreamInfo {
-+ uint64_t size;
-+ uint64_t cluster_count;
-+ uint64_t transferred;
-+ uint64_t zero_bytes;
-+ int finished;
-+ char *devname;
-+} VmaStreamInfo;
-+
-+typedef struct VmaStatus {
-+ int status;
-+ bool closed;
-+ char errmsg[8192];
-+ char uuid_str[37];
-+ VmaStreamInfo stream_info[256];
-+} VmaStatus;
-+
-+typedef struct VmaDeviceInfo {
-+ uint64_t size; /* device size in bytes */
-+ const char *devname;
-+} VmaDeviceInfo;
-+
-+VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp);
-+int vma_writer_close(VmaWriter *vmaw, Error **errp);
-+void vma_writer_error_propagate(VmaWriter *vmaw, Error **errp);
-+void vma_writer_destroy(VmaWriter *vmaw);
-+int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
-+ size_t len);
-+int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
-+ size_t size);
-+
-+int64_t coroutine_fn vma_writer_write(VmaWriter *vmaw, uint8_t dev_id,
-+ int64_t cluster_num,
-+ const unsigned char *buf,
-+ size_t *zero_bytes);
-+
-+int coroutine_fn vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id);
-+int coroutine_fn vma_writer_flush_output(VmaWriter *vmaw);
-+
-+int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status);
-+void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...);
-+
-+
-+VmaReader *vma_reader_create(const char *filename, Error **errp);
-+void vma_reader_destroy(VmaReader *vmar);
-+VmaHeader *vma_reader_get_header(VmaReader *vmar);
-+GList *vma_reader_get_config_data(VmaReader *vmar);
-+VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id);
-+int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id,
-+ BlockBackend *target, bool write_zeroes,
-+ Error **errp);
-+int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
-+ Error **errp);
-+int vma_reader_verify(VmaReader *vmar, bool verbose, Error **errp);
-+
-+#endif /* BACKUP_VMA_H */
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Dietmar Maurer <dietmar@proxmox.com>
-Date: Mon, 6 Apr 2020 12:16:58 +0200
-Subject: [PATCH] PVE-Backup: add backup-dump block driver
-
-- add backup-dump block driver block/backup-dump.c
-- move BackupBlockJob declaration from block/backup.c to include/block/block_int.h
-- block/backup.c - backup-job-create: also consider source cluster size
-- job.c: make job_should_pause non-static
----
- block/Makefile.objs | 1 +
- block/backup-dump.c | 168 ++++++++++++++++++++++++++++++++++++++
- block/backup.c | 23 ++----
- include/block/block_int.h | 30 +++++++
- job.c | 3 +-
- 5 files changed, 206 insertions(+), 19 deletions(-)
- create mode 100644 block/backup-dump.c
-
-diff --git a/block/Makefile.objs b/block/Makefile.objs
-index d1a9227b8f..9ea0477d0b 100644
---- a/block/Makefile.objs
-+++ b/block/Makefile.objs
-@@ -33,6 +33,7 @@ block-obj-$(CONFIG_CURL) += curl.o
- block-obj-$(CONFIG_RBD) += rbd.o
- block-obj-$(CONFIG_GLUSTERFS) += gluster.o
- block-obj-$(CONFIG_LIBSSH) += ssh.o
-+block-obj-y += backup-dump.o
- block-obj-y += accounting.o dirty-bitmap.o
- block-obj-y += write-threshold.o
- block-obj-y += backup.o
-diff --git a/block/backup-dump.c b/block/backup-dump.c
-new file mode 100644
-index 0000000000..93d7f46950
---- /dev/null
-+++ b/block/backup-dump.c
-@@ -0,0 +1,168 @@
-+/*
-+ * BlockDriver to send backup data stream to a callback function
-+ *
-+ * Copyright (C) 2020 Proxmox Server Solutions GmbH
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ *
-+ */
-+
-+#include "qemu/osdep.h"
-+#include "qemu-common.h"
-+#include "qom/object_interfaces.h"
-+#include "block/block_int.h"
-+
-+typedef struct {
-+ int dump_cb_block_size;
-+ uint64_t byte_size;
-+ BackupDumpFunc *dump_cb;
-+ void *dump_cb_data;
-+} BDRVBackupDumpState;
-+
-+static int qemu_backup_dump_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
-+{
-+ BDRVBackupDumpState *s = bs->opaque;
-+
-+ bdi->cluster_size = s->dump_cb_block_size;
-+ return 0;
-+}
-+
-+static int qemu_backup_dump_check_perm(
-+ BlockDriverState *bs,
-+ uint64_t perm,
-+ uint64_t shared,
-+ Error **errp)
-+{
-+ /* Nothing to do. */
-+ return 0;
-+}
-+
-+static void qemu_backup_dump_set_perm(
-+ BlockDriverState *bs,
-+ uint64_t perm,
-+ uint64_t shared)
-+{
-+ /* Nothing to do. */
-+}
-+
-+static void qemu_backup_dump_abort_perm_update(BlockDriverState *bs)
-+{
-+ /* Nothing to do. */
-+}
-+
-+static void qemu_backup_dump_refresh_limits(BlockDriverState *bs, Error **errp)
-+{
-+ bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
-+}
-+
-+static void qemu_backup_dump_close(BlockDriverState *bs)
-+{
-+ /* Nothing to do. */
-+}
-+
-+static int64_t qemu_backup_dump_getlength(BlockDriverState *bs)
-+{
-+ BDRVBackupDumpState *s = bs->opaque;
-+
-+ return s->byte_size;
-+}
-+
-+static coroutine_fn int qemu_backup_dump_co_writev(
-+ BlockDriverState *bs,
-+ int64_t sector_num,
-+ int nb_sectors,
-+ QEMUIOVector *qiov,
-+ int flags)
-+{
-+ /* flags can be only values we set in supported_write_flags */
-+ assert(flags == 0);
-+
-+ BDRVBackupDumpState *s = bs->opaque;
-+ off_t offset = sector_num * BDRV_SECTOR_SIZE;
-+
-+ uint64_t written = 0;
-+
-+ for (int i = 0; i < qiov->niov; ++i) {
-+ const struct iovec *v = &qiov->iov[i];
-+
-+ int rc = s->dump_cb(s->dump_cb_data, offset, v->iov_len, v->iov_base);
-+ if (rc < 0) {
-+ return rc;
-+ }
-+
-+ if (rc != v->iov_len) {
-+ return -EIO;
-+ }
-+
-+ written += v->iov_len;
-+ offset += v->iov_len;
-+ }
-+
-+ return written;
-+}
-+
-+static void qemu_backup_dump_child_perm(
-+ BlockDriverState *bs,
-+ BdrvChild *c,
-+ BdrvChildRole role,
-+ BlockReopenQueue *reopen_queue,
-+ uint64_t perm, uint64_t shared,
-+ uint64_t *nperm, uint64_t *nshared)
-+{
-+ *nperm = BLK_PERM_ALL;
-+ *nshared = BLK_PERM_ALL;
-+}
-+
-+static BlockDriver bdrv_backup_dump_drive = {
-+ .format_name = "backup-dump-drive",
-+ .protocol_name = "backup-dump",
-+ .instance_size = sizeof(BDRVBackupDumpState),
-+
-+ .bdrv_close = qemu_backup_dump_close,
-+ .bdrv_has_zero_init = bdrv_has_zero_init_1,
-+ .bdrv_getlength = qemu_backup_dump_getlength,
-+ .bdrv_get_info = qemu_backup_dump_get_info,
-+
-+ .bdrv_co_writev = qemu_backup_dump_co_writev,
-+
-+ .bdrv_refresh_limits = qemu_backup_dump_refresh_limits,
-+ .bdrv_check_perm = qemu_backup_dump_check_perm,
-+ .bdrv_set_perm = qemu_backup_dump_set_perm,
-+ .bdrv_abort_perm_update = qemu_backup_dump_abort_perm_update,
-+ .bdrv_child_perm = qemu_backup_dump_child_perm,
-+};
-+
-+static void bdrv_backup_dump_init(void)
-+{
-+ bdrv_register(&bdrv_backup_dump_drive);
-+}
-+
-+block_init(bdrv_backup_dump_init);
-+
-+
-+BlockDriverState *bdrv_backup_dump_create(
-+ int dump_cb_block_size,
-+ uint64_t byte_size,
-+ BackupDumpFunc *dump_cb,
-+ void *dump_cb_data,
-+ Error **errp)
-+{
-+ BDRVBackupDumpState *state;
-+ BlockDriverState *bs = bdrv_new_open_driver(
-+ &bdrv_backup_dump_drive, NULL, BDRV_O_RDWR, errp);
-+
-+ if (!bs) {
-+ return NULL;
-+ }
-+
-+ bs->total_sectors = byte_size / BDRV_SECTOR_SIZE;
-+ bs->opaque = state = g_new0(BDRVBackupDumpState, 1);
-+
-+ state->dump_cb_block_size = dump_cb_block_size;
-+ state->byte_size = byte_size;
-+ state->dump_cb = dump_cb;
-+ state->dump_cb_data = dump_cb_data;
-+
-+ return bs;
-+}
-diff --git a/block/backup.c b/block/backup.c
-index 5f373a4f9b..1bcc7faa32 100644
---- a/block/backup.c
-+++ b/block/backup.c
-@@ -32,24 +32,6 @@
-
- #define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
-
--typedef struct BackupBlockJob {
-- BlockJob common;
-- BlockDriverState *backup_top;
-- BlockDriverState *source_bs;
--
-- BdrvDirtyBitmap *sync_bitmap;
--
-- MirrorSyncMode sync_mode;
-- BitmapSyncMode bitmap_mode;
-- BlockdevOnError on_source_error;
-- BlockdevOnError on_target_error;
-- uint64_t len;
-- uint64_t bytes_read;
-- int64_t cluster_size;
--
-- BlockCopyState *bcs;
--} BackupBlockJob;
--
- static const BlockJobDriver backup_job_driver;
-
- static void backup_progress_bytes_callback(int64_t bytes, void *opaque)
-@@ -423,6 +405,11 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
- goto error;
- }
-
-+ BlockDriverInfo bdi;
-+ if (bdrv_get_info(bs, &bdi) == 0) {
-+ cluster_size = MAX(cluster_size, bdi.cluster_size);
-+ }
-+
- /*
- * If source is in backing chain of target assume that target is going to be
- * used for "image fleecing", i.e. it should represent a kind of snapshot of
-diff --git a/include/block/block_int.h b/include/block/block_int.h
-index 5094ae1e95..dc72197388 100644
---- a/include/block/block_int.h
-+++ b/include/block/block_int.h
-@@ -62,6 +62,36 @@
-
- #define BLOCK_PROBE_BUF_SIZE 512
-
-+typedef int BackupDumpFunc(void *opaque, uint64_t offset, uint64_t bytes, const void *buf);
-+
-+BlockDriverState *bdrv_backuo_dump_create(
-+ int dump_cb_block_size,
-+ uint64_t byte_size,
-+ BackupDumpFunc *dump_cb,
-+ void *dump_cb_data,
-+ Error **errp);
-+
-+// Needs to be defined here, since it's used in blockdev.c to detect PVE backup
-+// jobs with source_bs
-+typedef struct BlockCopyState BlockCopyState;
-+typedef struct BackupBlockJob {
-+ BlockJob common;
-+ BlockDriverState *backup_top;
-+ BlockDriverState *source_bs;
-+
-+ BdrvDirtyBitmap *sync_bitmap;
-+
-+ MirrorSyncMode sync_mode;
-+ BitmapSyncMode bitmap_mode;
-+ BlockdevOnError on_source_error;
-+ BlockdevOnError on_target_error;
-+ uint64_t len;
-+ uint64_t bytes_read;
-+ int64_t cluster_size;
-+
-+ BlockCopyState *bcs;
-+} BackupBlockJob;
-+
- enum BdrvTrackedRequestType {
- BDRV_TRACKED_READ,
- BDRV_TRACKED_WRITE,
-diff --git a/job.c b/job.c
-index e82253e041..bcbbb0be02 100644
---- a/job.c
-+++ b/job.c
-@@ -269,7 +269,8 @@ static bool job_started(Job *job)
- return job->co;
- }
-
--static bool job_should_pause(Job *job)
-+bool job_should_pause(Job *job);
-+bool job_should_pause(Job *job)
- {
- return job->pause_count > 0;
- }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dietmar Maurer <dietmar@proxmox.com>
+Date: Mon, 6 Apr 2020 12:16:59 +0200
+Subject: [PATCH] PVE-Backup: proxmox backup patches for qemu
+
+---
+ Makefile | 1 +
+ Makefile.objs | 2 +
+ Makefile.target | 2 +-
+ block/monitor/block-hmp-cmds.c | 33 ++
+ blockdev.c | 1 +
+ hmp-commands-info.hx | 13 +
+ hmp-commands.hx | 29 +
+ include/block/block_int.h | 2 +-
+ include/monitor/hmp.h | 3 +
+ monitor/hmp-cmds.c | 44 ++
+ proxmox-backup-client.c | 182 +++++++
+ proxmox-backup-client.h | 52 ++
+ pve-backup.c | 955 +++++++++++++++++++++++++++++++++
+ qapi/block-core.json | 109 ++++
+ qapi/common.json | 13 +
+ qapi/misc.json | 13 -
+ 16 files changed, 1439 insertions(+), 15 deletions(-)
+ create mode 100644 proxmox-backup-client.c
+ create mode 100644 proxmox-backup-client.h
+ create mode 100644 pve-backup.c
+
+diff --git a/Makefile b/Makefile
+index 7b8c17ce2d..aec216968d 100644
+--- a/Makefile
++++ b/Makefile
+@@ -602,6 +602,7 @@ qemu-img$(EXESUF): qemu-img.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io
+ qemu-nbd$(EXESUF): qemu-nbd.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
+ qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
+ qemu-storage-daemon$(EXESUF): qemu-storage-daemon.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(chardev-obj-y) $(io-obj-y) $(qom-obj-y) $(storage-daemon-obj-y) $(COMMON_LDADDS)
++qemu-storage-daemon$(EXESUF): LIBS += -lproxmox_backup_qemu
+ vma$(EXESUF): vma.o vma-reader.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
+
+ qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
+diff --git a/Makefile.objs b/Makefile.objs
+index ade7b17a69..240eb503f2 100644
+--- a/Makefile.objs
++++ b/Makefile.objs
+@@ -33,6 +33,7 @@ endif # CONFIG_SOFTMMU or CONFIG_TOOLS
+
+ storage-daemon-obj-y = block/ monitor/ qapi/ qom/ storage-daemon/
+ storage-daemon-obj-y += blockdev.o blockdev-nbd.o iothread.o job-qmp.o
++storage-daemon-obj-y += proxmox-backup-client.o pve-backup.o
+ storage-daemon-obj-$(CONFIG_WIN32) += os-win32.o
+ storage-daemon-obj-$(CONFIG_POSIX) += os-posix.o
+
+@@ -44,6 +45,7 @@ storage-daemon-obj-$(CONFIG_POSIX) += os-posix.o
+ ifeq ($(CONFIG_SOFTMMU),y)
+ common-obj-y = blockdev.o blockdev-nbd.o block/
+ common-obj-y += bootdevice.o iothread.o
++common-obj-y += proxmox-backup-client.o pve-backup.o
+ common-obj-y += dump/
+ common-obj-y += job-qmp.o
+ common-obj-y += monitor/
+diff --git a/Makefile.target b/Makefile.target
+index ffa2657269..fd3fd6d2a7 100644
+--- a/Makefile.target
++++ b/Makefile.target
+@@ -159,7 +159,7 @@ obj-y += hw/
+ obj-y += monitor/
+ obj-y += qapi/
+ obj-y += migration/ram.o
+-LIBS := $(libs_softmmu) $(LIBS)
++LIBS := $(libs_softmmu) $(LIBS) -lproxmox_backup_qemu
+
+ # Hardware support
+ ifeq ($(TARGET_NAME), sparc64)
+diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
+index 4c8c375172..d485c3ac79 100644
+--- a/block/monitor/block-hmp-cmds.c
++++ b/block/monitor/block-hmp-cmds.c
+@@ -1011,3 +1011,36 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
+ g_free(sn_tab);
+ g_free(global_snapshots);
+ }
++
++void hmp_backup_cancel(Monitor *mon, const QDict *qdict)
++{
++ Error *error = NULL;
++
++ qmp_backup_cancel(&error);
++
++ hmp_handle_error(mon, error);
++}
++
++void hmp_backup(Monitor *mon, const QDict *qdict)
++{
++ Error *error = NULL;
++
++ int dir = qdict_get_try_bool(qdict, "directory", 0);
++ const char *backup_file = qdict_get_str(qdict, "backupfile");
++ const char *devlist = qdict_get_try_str(qdict, "devlist");
++ int64_t speed = qdict_get_try_int(qdict, "speed", 0);
++
++ qmp_backup(
++ backup_file,
++ false, NULL, // PBS password
++ false, NULL, // PBS keyfile
++ false, NULL, // PBS key_password
++ false, NULL, // PBS fingerprint
++ false, NULL, // PBS backup-id
++ false, 0, // PBS backup-time
++ true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
++ false, NULL, false, NULL, !!devlist,
++ devlist, qdict_haskey(qdict, "speed"), speed, &error);
++
++ hmp_handle_error(mon, error);
++}
+diff --git a/blockdev.c b/blockdev.c
+index 3848a9c8ab..681da7c8b6 100644
+--- a/blockdev.c
++++ b/blockdev.c
+@@ -36,6 +36,7 @@
+ #include "hw/block/block.h"
+ #include "block/blockjob.h"
+ #include "block/qdict.h"
++#include "block/blockjob_int.h"
+ #include "block/throttle-groups.h"
+ #include "monitor/monitor.h"
+ #include "qemu/error-report.h"
+diff --git a/hmp-commands-info.hx b/hmp-commands-info.hx
+index ae8ff21789..da16499f8d 100644
+--- a/hmp-commands-info.hx
++++ b/hmp-commands-info.hx
+@@ -513,6 +513,19 @@ SRST
+ Show CPU statistics.
+ ERST
+
++ {
++ .name = "backup",
++ .args_type = "",
++ .params = "",
++ .help = "show backup status",
++ .cmd = hmp_info_backup,
++ },
++
++SRST
++ ``info backup``
++ Show backup status.
++ERST
++
+ #if defined(CONFIG_SLIRP)
+ {
+ .name = "usernet",
+diff --git a/hmp-commands.hx b/hmp-commands.hx
+index 2b58ac4a1c..9e58b6a5fc 100644
+--- a/hmp-commands.hx
++++ b/hmp-commands.hx
+@@ -97,6 +97,35 @@ ERST
+ SRST
+ ``block_stream``
+ Copy data from a backing file into a block device.
++ERST
++
++ {
++ .name = "backup",
++ .args_type = "directory:-d,backupfile:s,speed:o?,devlist:s?",
++ .params = "[-d] backupfile [speed [devlist]]",
++ .help = "create a VM Backup."
++ "\n\t\t\t Use -d to dump data into a directory instead"
++ "\n\t\t\t of using VMA format.",
++ .cmd = hmp_backup,
++ },
++
++SRST
++``backup``
++ Create a VM backup.
++ERST
++
++ {
++ .name = "backup_cancel",
++ .args_type = "",
++ .params = "",
++ .help = "cancel the current VM backup",
++ .cmd = hmp_backup_cancel,
++ },
++
++SRST
++``backup_cancel``
++ Cancel the current VM backup.
++
+ ERST
+
+ {
+diff --git a/include/block/block_int.h b/include/block/block_int.h
+index 1efb1f527c..8dda6f769d 100644
+--- a/include/block/block_int.h
++++ b/include/block/block_int.h
+@@ -64,7 +64,7 @@
+
+ typedef int BackupDumpFunc(void *opaque, uint64_t offset, uint64_t bytes, const void *buf);
+
+-BlockDriverState *bdrv_backuo_dump_create(
++BlockDriverState *bdrv_backup_dump_create(
+ int dump_cb_block_size,
+ uint64_t byte_size,
+ BackupDumpFunc *dump_cb,
+diff --git a/include/monitor/hmp.h b/include/monitor/hmp.h
+index 243952d32f..892a6064be 100644
+--- a/include/monitor/hmp.h
++++ b/include/monitor/hmp.h
+@@ -30,6 +30,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict);
+ void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict);
+ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict);
+ void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict);
++void hmp_info_backup(Monitor *mon, const QDict *qdict);
+ void hmp_info_cpus(Monitor *mon, const QDict *qdict);
+ void hmp_info_vnc(Monitor *mon, const QDict *qdict);
+ void hmp_info_spice(Monitor *mon, const QDict *qdict);
+@@ -76,6 +77,8 @@ void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict);
+ void hmp_set_password(Monitor *mon, const QDict *qdict);
+ void hmp_expire_password(Monitor *mon, const QDict *qdict);
+ void hmp_change(Monitor *mon, const QDict *qdict);
++void hmp_backup(Monitor *mon, const QDict *qdict);
++void hmp_backup_cancel(Monitor *mon, const QDict *qdict);
+ void hmp_migrate(Monitor *mon, const QDict *qdict);
+ void hmp_device_add(Monitor *mon, const QDict *qdict);
+ void hmp_device_del(Monitor *mon, const QDict *qdict);
+diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
+index 280bb447a6..0e2d166552 100644
+--- a/monitor/hmp-cmds.c
++++ b/monitor/hmp-cmds.c
+@@ -192,6 +192,50 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
+ qapi_free_MouseInfoList(mice_list);
+ }
+
++void hmp_info_backup(Monitor *mon, const QDict *qdict)
++{
++ BackupStatus *info;
++
++ info = qmp_query_backup(NULL);
++
++ if (!info) {
++ monitor_printf(mon, "Backup status: not initialized\n");
++ return;
++ }
++
++ if (info->has_status) {
++ if (info->has_errmsg) {
++ monitor_printf(mon, "Backup status: %s - %s\n",
++ info->status, info->errmsg);
++ } else {
++ monitor_printf(mon, "Backup status: %s\n", info->status);
++ }
++ }
++
++ if (info->has_backup_file) {
++ monitor_printf(mon, "Start time: %s", ctime(&info->start_time));
++ if (info->end_time) {
++ monitor_printf(mon, "End time: %s", ctime(&info->end_time));
++ }
++
++ int per = (info->has_total && info->total &&
++ info->has_transferred && info->transferred) ?
++ (info->transferred * 100)/info->total : 0;
++ int zero_per = (info->has_total && info->total &&
++ info->has_zero_bytes && info->zero_bytes) ?
++ (info->zero_bytes * 100)/info->total : 0;
++ monitor_printf(mon, "Backup file: %s\n", info->backup_file);
++ monitor_printf(mon, "Backup uuid: %s\n", info->uuid);
++ monitor_printf(mon, "Total size: %zd\n", info->total);
++ monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
++ info->transferred, per);
++ monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
++ info->zero_bytes, zero_per);
++ }
++
++ qapi_free_BackupStatus(info);
++}
++
+ static char *SocketAddress_to_str(SocketAddress *addr)
+ {
+ switch (addr->type) {
+diff --git a/proxmox-backup-client.c b/proxmox-backup-client.c
+new file mode 100644
+index 0000000000..b7bc7f2574
+--- /dev/null
++++ b/proxmox-backup-client.c
+@@ -0,0 +1,182 @@
++#include "proxmox-backup-client.h"
++#include "qemu/main-loop.h"
++#include "block/aio-wait.h"
++#include "qapi/error.h"
++
++/* Proxmox Backup Server client bindings using coroutines */
++
++typedef struct BlockOnCoroutineWrapper {
++ AioContext *ctx;
++ CoroutineEntry *entry;
++ void *entry_arg;
++ bool finished;
++} BlockOnCoroutineWrapper;
++
++// Waker implementaion to syncronice with proxmox backup rust code
++typedef struct ProxmoxBackupWaker {
++ Coroutine *co;
++ AioContext *ctx;
++} ProxmoxBackupWaker;
++
++static void coroutine_fn block_on_coroutine_wrapper(void *opaque)
++{
++ BlockOnCoroutineWrapper *wrapper = opaque;
++ wrapper->entry(wrapper->entry_arg);
++ wrapper->finished = true;
++ aio_wait_kick();
++}
++
++void block_on_coroutine_fn(CoroutineEntry *entry, void *entry_arg)
++{
++ assert(!qemu_in_coroutine());
++
++ AioContext *ctx = qemu_get_current_aio_context();
++ BlockOnCoroutineWrapper wrapper = {
++ .finished = false,
++ .entry = entry,
++ .entry_arg = entry_arg,
++ .ctx = ctx,
++ };
++ Coroutine *wrapper_co = qemu_coroutine_create(block_on_coroutine_wrapper, &wrapper);
++ aio_co_enter(ctx, wrapper_co);
++ AIO_WAIT_WHILE(ctx, !wrapper.finished);
++}
++
++// This is called from another thread, so we use aio_co_schedule()
++static void proxmox_backup_schedule_wake(void *data) {
++ ProxmoxBackupWaker *waker = (ProxmoxBackupWaker *)data;
++ aio_co_schedule(waker->ctx, waker->co);
++}
++
++int coroutine_fn
++proxmox_backup_co_connect(ProxmoxBackupHandle *pbs, Error **errp)
++{
++ Coroutine *co = qemu_coroutine_self();
++ AioContext *ctx = qemu_get_current_aio_context();
++ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
++ char *pbs_err = NULL;
++ int pbs_res = -1;
++
++ proxmox_backup_connect_async(pbs, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
++ qemu_coroutine_yield();
++ if (pbs_res < 0) {
++ if (errp) error_setg(errp, "backup connect failed: %s", pbs_err ? pbs_err : "unknown error");
++ if (pbs_err) proxmox_backup_free_error(pbs_err);
++ }
++ return pbs_res;
++}
++
++int coroutine_fn
++proxmox_backup_co_add_config(
++ ProxmoxBackupHandle *pbs,
++ const char *name,
++ const uint8_t *data,
++ uint64_t size,
++ Error **errp)
++{
++ Coroutine *co = qemu_coroutine_self();
++ AioContext *ctx = qemu_get_current_aio_context();
++ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
++ char *pbs_err = NULL;
++ int pbs_res = -1;
++
++ proxmox_backup_add_config_async(
++ pbs, name, data, size ,proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
++ qemu_coroutine_yield();
++ if (pbs_res < 0) {
++ if (errp) error_setg(errp, "backup add_config %s failed: %s", name, pbs_err ? pbs_err : "unknown error");
++ if (pbs_err) proxmox_backup_free_error(pbs_err);
++ }
++ return pbs_res;
++}
++
++int coroutine_fn
++proxmox_backup_co_register_image(
++ ProxmoxBackupHandle *pbs,
++ const char *device_name,
++ uint64_t size,
++ Error **errp)
++{
++ Coroutine *co = qemu_coroutine_self();
++ AioContext *ctx = qemu_get_current_aio_context();
++ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
++ char *pbs_err = NULL;
++ int pbs_res = -1;
++
++ proxmox_backup_register_image_async(
++ pbs, device_name, size ,proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
++ qemu_coroutine_yield();
++ if (pbs_res < 0) {
++ if (errp) error_setg(errp, "backup register image failed: %s", pbs_err ? pbs_err : "unknown error");
++ if (pbs_err) proxmox_backup_free_error(pbs_err);
++ }
++ return pbs_res;
++}
++
++int coroutine_fn
++proxmox_backup_co_finish(
++ ProxmoxBackupHandle *pbs,
++ Error **errp)
++{
++ Coroutine *co = qemu_coroutine_self();
++ AioContext *ctx = qemu_get_current_aio_context();
++ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
++ char *pbs_err = NULL;
++ int pbs_res = -1;
++
++ proxmox_backup_finish_async(
++ pbs, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
++ qemu_coroutine_yield();
++ if (pbs_res < 0) {
++ if (errp) error_setg(errp, "backup finish failed: %s", pbs_err ? pbs_err : "unknown error");
++ if (pbs_err) proxmox_backup_free_error(pbs_err);
++ }
++ return pbs_res;
++}
++
++int coroutine_fn
++proxmox_backup_co_close_image(
++ ProxmoxBackupHandle *pbs,
++ uint8_t dev_id,
++ Error **errp)
++{
++ Coroutine *co = qemu_coroutine_self();
++ AioContext *ctx = qemu_get_current_aio_context();
++ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
++ char *pbs_err = NULL;
++ int pbs_res = -1;
++
++ proxmox_backup_close_image_async(
++ pbs, dev_id, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
++ qemu_coroutine_yield();
++ if (pbs_res < 0) {
++ if (errp) error_setg(errp, "backup close image failed: %s", pbs_err ? pbs_err : "unknown error");
++ if (pbs_err) proxmox_backup_free_error(pbs_err);
++ }
++ return pbs_res;
++}
++
++int coroutine_fn
++proxmox_backup_co_write_data(
++ ProxmoxBackupHandle *pbs,
++ uint8_t dev_id,
++ const uint8_t *data,
++ uint64_t offset,
++ uint64_t size,
++ Error **errp)
++{
++ Coroutine *co = qemu_coroutine_self();
++ AioContext *ctx = qemu_get_current_aio_context();
++ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
++ char *pbs_err = NULL;
++ int pbs_res = -1;
++
++ proxmox_backup_write_data_async(
++ pbs, dev_id, data, offset, size, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
++ qemu_coroutine_yield();
++ if (pbs_res < 0) {
++ if (errp) error_setg(errp, "backup write data failed: %s", pbs_err ? pbs_err : "unknown error");
++ if (pbs_err) proxmox_backup_free_error(pbs_err);
++ }
++ return pbs_res;
++}
+diff --git a/proxmox-backup-client.h b/proxmox-backup-client.h
+new file mode 100644
+index 0000000000..b311bf8de8
+--- /dev/null
++++ b/proxmox-backup-client.h
+@@ -0,0 +1,52 @@
++#ifndef PROXMOX_BACKUP_CLIENT_H
++#define PROXMOX_BACKUP_CLIENT_H
++
++#include "qemu/osdep.h"
++#include "qemu/coroutine.h"
++#include "proxmox-backup-qemu.h"
++
++void block_on_coroutine_fn(CoroutineEntry *entry, void *entry_arg);
++
++int coroutine_fn
++proxmox_backup_co_connect(
++ ProxmoxBackupHandle *pbs,
++ Error **errp);
++
++int coroutine_fn
++proxmox_backup_co_add_config(
++ ProxmoxBackupHandle *pbs,
++ const char *name,
++ const uint8_t *data,
++ uint64_t size,
++ Error **errp);
++
++int coroutine_fn
++proxmox_backup_co_register_image(
++ ProxmoxBackupHandle *pbs,
++ const char *device_name,
++ uint64_t size,
++ Error **errp);
++
++
++int coroutine_fn
++proxmox_backup_co_finish(
++ ProxmoxBackupHandle *pbs,
++ Error **errp);
++
++int coroutine_fn
++proxmox_backup_co_close_image(
++ ProxmoxBackupHandle *pbs,
++ uint8_t dev_id,
++ Error **errp);
++
++int coroutine_fn
++proxmox_backup_co_write_data(
++ ProxmoxBackupHandle *pbs,
++ uint8_t dev_id,
++ const uint8_t *data,
++ uint64_t offset,
++ uint64_t size,
++ Error **errp);
++
++
++#endif /* PROXMOX_BACKUP_CLIENT_H */
+diff --git a/pve-backup.c b/pve-backup.c
+new file mode 100644
+index 0000000000..55441eb9d1
+--- /dev/null
++++ b/pve-backup.c
+@@ -0,0 +1,955 @@
++#include "proxmox-backup-client.h"
++#include "vma.h"
++
++#include "qemu/osdep.h"
++#include "qemu/module.h"
++#include "sysemu/block-backend.h"
++#include "sysemu/blockdev.h"
++#include "block/blockjob.h"
++#include "qapi/qapi-commands-block.h"
++#include "qapi/qmp/qerror.h"
++
++/* PVE backup state and related function */
++
++
++static struct PVEBackupState {
++ struct {
++ // Everithing accessed from qmp command, protected using rwlock
++ CoRwlock rwlock;
++ Error *error;
++ time_t start_time;
++ time_t end_time;
++ char *backup_file;
++ uuid_t uuid;
++ char uuid_str[37];
++ size_t total;
++ size_t transferred;
++ size_t zero_bytes;
++ bool cancel;
++ } stat;
++ int64_t speed;
++ VmaWriter *vmaw;
++ ProxmoxBackupHandle *pbs;
++ GList *di_list;
++ CoMutex backup_mutex;
++} backup_state;
++
++static void pvebackup_init(void)
++{
++ qemu_co_rwlock_init(&backup_state.stat.rwlock);
++ qemu_co_mutex_init(&backup_state.backup_mutex);
++}
++
++// initialize PVEBackupState at startup
++opts_init(pvebackup_init);
++
++typedef struct PVEBackupDevInfo {
++ BlockDriverState *bs;
++ size_t size;
++ uint8_t dev_id;
++ bool completed;
++ char targetfile[PATH_MAX];
++ BlockDriverState *target;
++} PVEBackupDevInfo;
++
++static void pvebackup_co_run_next_job(void);
++
++static int coroutine_fn
++pvebackup_co_dump_cb(
++ void *opaque,
++ uint64_t start,
++ uint64_t bytes,
++ const void *pbuf)
++{
++ assert(qemu_in_coroutine());
++
++ const uint64_t size = bytes;
++ const unsigned char *buf = pbuf;
++ PVEBackupDevInfo *di = opaque;
++
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ bool cancel = backup_state.stat.cancel;
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ if (cancel) {
++ return size; // return success
++ }
++
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
++ int ret = -1;
++
++ if (backup_state.vmaw) {
++ size_t zero_bytes = 0;
++ uint64_t remaining = size;
++
++ uint64_t cluster_num = start / VMA_CLUSTER_SIZE;
++ if ((cluster_num * VMA_CLUSTER_SIZE) != start) {
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ if (!backup_state.stat.error) {
++ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
++ error_setg(&backup_state.stat.error,
++ "got unaligned write inside backup dump "
++ "callback (sector %ld)", start);
++ }
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ return -1; // not aligned to cluster size
++ }
++
++ while (remaining > 0) {
++ ret = vma_writer_write(backup_state.vmaw, di->dev_id, cluster_num,
++ buf, &zero_bytes);
++ ++cluster_num;
++ if (buf) {
++ buf += VMA_CLUSTER_SIZE;
++ }
++ if (ret < 0) {
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ if (!backup_state.stat.error) {
++ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
++ vma_writer_error_propagate(backup_state.vmaw, &backup_state.stat.error);
++ }
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ return ret;
++ } else {
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ backup_state.stat.zero_bytes += zero_bytes;
++ if (remaining >= VMA_CLUSTER_SIZE) {
++ backup_state.stat.transferred += VMA_CLUSTER_SIZE;
++ remaining -= VMA_CLUSTER_SIZE;
++ } else {
++ backup_state.stat.transferred += remaining;
++ remaining = 0;
++ }
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ }
++ }
++ } else if (backup_state.pbs) {
++ Error *local_err = NULL;
++ int pbs_res = -1;
++
++ pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
++
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++
++ if (pbs_res < 0) {
++ error_propagate(&backup_state.stat.error, local_err);
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ return pbs_res;
++ } else {
++ if (!buf) {
++ backup_state.stat.zero_bytes += size;
++ }
++ backup_state.stat.transferred += size;
++ }
++
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ } else {
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ if (!buf) {
++ backup_state.stat.zero_bytes += size;
++ }
++ backup_state.stat.transferred += size;
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ }
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++
++ return size;
++}
++
++static void coroutine_fn pvebackup_co_cleanup(void)
++{
++ assert(qemu_in_coroutine());
++
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ backup_state.stat.end_time = time(NULL);
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ if (backup_state.vmaw) {
++ Error *local_err = NULL;
++ vma_writer_close(backup_state.vmaw, &local_err);
++
++ if (local_err != NULL) {
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ error_propagate(&backup_state.stat.error, local_err);
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ }
++
++ backup_state.vmaw = NULL;
++ }
++
++ if (backup_state.pbs) {
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
++ if (!error_or_canceled) {
++ Error *local_err = NULL;
++ proxmox_backup_co_finish(backup_state.pbs, &local_err);
++ if (local_err != NULL) {
++ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
++ error_propagate(&backup_state.stat.error, local_err);
++ }
++ }
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ proxmox_backup_disconnect(backup_state.pbs);
++ backup_state.pbs = NULL;
++ }
++
++ g_list_free(backup_state.di_list);
++ backup_state.di_list = NULL;
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++}
++
++typedef struct PVEBackupCompeteCallbackData {
++ PVEBackupDevInfo *di;
++ int result;
++} PVEBackupCompeteCallbackData;
++
++static void coroutine_fn pvebackup_co_complete_cb(void *opaque)
++{
++ assert(qemu_in_coroutine());
++
++ PVEBackupCompeteCallbackData *cb_data = opaque;
++
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
++ PVEBackupDevInfo *di = cb_data->di;
++ int ret = cb_data->result;
++
++ di->completed = true;
++
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
++
++ if (ret < 0 && !backup_state.stat.error) {
++ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
++ error_setg(&backup_state.stat.error, "job failed with err %d - %s",
++ ret, strerror(-ret));
++ }
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ di->bs = NULL;
++
++ if (di->target) {
++ bdrv_unref(di->target);
++ di->target = NULL;
++ }
++
++ if (backup_state.vmaw) {
++ vma_writer_close_stream(backup_state.vmaw, di->dev_id);
++ }
++
++ if (backup_state.pbs && !error_or_canceled) {
++ Error *local_err = NULL;
++ proxmox_backup_co_close_image(backup_state.pbs, di->dev_id, &local_err);
++ if (local_err != NULL) {
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ error_propagate(&backup_state.stat.error, local_err);
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ }
++ }
++
++ // remove self from job queue
++ backup_state.di_list = g_list_remove(backup_state.di_list, di);
++ g_free(di);
++
++ int pending_jobs = g_list_length(backup_state.di_list);
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++
++ if (pending_jobs > 0) {
++ pvebackup_co_run_next_job();
++ } else {
++ pvebackup_co_cleanup();
++ }
++}
++
++static void pvebackup_complete_cb(void *opaque, int ret)
++{
++ // This can be called from the main loop, or from a coroutine
++ PVEBackupCompeteCallbackData cb_data = {
++ .di = opaque,
++ .result = ret,
++ };
++
++ if (qemu_in_coroutine()) {
++ pvebackup_co_complete_cb(&cb_data);
++ } else {
++ block_on_coroutine_fn(pvebackup_co_complete_cb, &cb_data);
++ }
++}
++
++static void coroutine_fn pvebackup_co_cancel(void *opaque)
++{
++ assert(qemu_in_coroutine());
++
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ backup_state.stat.cancel = true;
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
++ // Avoid race between block jobs and backup-cancel command:
++ if (!(backup_state.vmaw || backup_state.pbs)) {
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ return;
++ }
++
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ if (!backup_state.stat.error) {
++ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
++ error_setg(&backup_state.stat.error, "backup cancelled");
++ }
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ if (backup_state.vmaw) {
++ /* make sure vma writer does not block anymore */
++ vma_writer_set_error(backup_state.vmaw, "backup cancelled");
++ }
++
++ if (backup_state.pbs) {
++ proxmox_backup_abort(backup_state.pbs, "backup cancelled");
++ }
++
++ bool running_jobs = 0;
++ GList *l = backup_state.di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++ if (!di->completed && di->bs) {
++ for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
++ if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
++ continue;
++ }
++
++ BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
++ if (bjob && bjob->source_bs == di->bs) {
++ AioContext *aio_context = job->job.aio_context;
++ aio_context_acquire(aio_context);
++
++ if (!di->completed) {
++ running_jobs += 1;
++ job_cancel(&job->job, false);
++ }
++ aio_context_release(aio_context);
++ }
++ }
++ }
++ }
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++
++ if (running_jobs == 0) pvebackup_co_cleanup(); // else job will call completion handler
++}
++
++void qmp_backup_cancel(Error **errp)
++{
++ block_on_coroutine_fn(pvebackup_co_cancel, NULL);
++}
++
++static int coroutine_fn pvebackup_co_add_config(
++ const char *file,
++ const char *name,
++ BackupFormat format,
++ const char *backup_dir,
++ VmaWriter *vmaw,
++ ProxmoxBackupHandle *pbs,
++ Error **errp)
++{
++ int res = 0;
++
++ char *cdata = NULL;
++ gsize clen = 0;
++ GError *err = NULL;
++ if (!g_file_get_contents(file, &cdata, &clen, &err)) {
++ error_setg(errp, "unable to read file '%s'", file);
++ return 1;
++ }
++
++ char *basename = g_path_get_basename(file);
++ if (name == NULL) name = basename;
++
++ if (format == BACKUP_FORMAT_VMA) {
++ if (vma_writer_add_config(vmaw, name, cdata, clen) != 0) {
++ error_setg(errp, "unable to add %s config data to vma archive", file);
++ goto err;
++ }
++ } else if (format == BACKUP_FORMAT_PBS) {
++ if (proxmox_backup_co_add_config(pbs, name, (unsigned char *)cdata, clen, errp) < 0)
++ goto err;
++ } else if (format == BACKUP_FORMAT_DIR) {
++ char config_path[PATH_MAX];
++ snprintf(config_path, PATH_MAX, "%s/%s", backup_dir, name);
++ if (!g_file_set_contents(config_path, cdata, clen, &err)) {
++ error_setg(errp, "unable to write config file '%s'", config_path);
++ goto err;
++ }
++ }
++
++ out:
++ g_free(basename);
++ g_free(cdata);
++ return res;
++
++ err:
++ res = -1;
++ goto out;
++}
++
++bool job_should_pause(Job *job);
++
++static void coroutine_fn pvebackup_co_run_next_job(void)
++{
++ assert(qemu_in_coroutine());
++
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
++ GList *l = backup_state.di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++ if (!di->completed && di->bs) {
++ for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
++ if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
++ continue;
++ }
++
++ BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
++ if (bjob && bjob->source_bs == di->bs) {
++ AioContext *aio_context = job->job.aio_context;
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ aio_context_acquire(aio_context);
++
++ if (job_should_pause(&job->job)) {
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ if (error_or_canceled) {
++ job_cancel(&job->job, false);
++ } else {
++ job_resume(&job->job);
++ }
++ }
++ aio_context_release(aio_context);
++ return;
++ }
++ }
++ }
++ }
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++}
++
++typedef struct QmpBackupTask {
++ const char *backup_file;
++ bool has_password;
++ const char *password;
++ bool has_keyfile;
++ const char *keyfile;
++ bool has_key_password;
++ const char *key_password;
++ bool has_backup_id;
++ const char *backup_id;
++ bool has_backup_time;
++ const char *fingerprint;
++ bool has_fingerprint;
++ int64_t backup_time;
++ bool has_format;
++ BackupFormat format;
++ bool has_config_file;
++ const char *config_file;
++ bool has_firewall_file;
++ const char *firewall_file;
++ bool has_devlist;
++ const char *devlist;
++ bool has_speed;
++ int64_t speed;
++ Error **errp;
++ UuidInfo *result;
++} QmpBackupTask;
++
++static void coroutine_fn pvebackup_co_start(void *opaque)
++{
++ assert(qemu_in_coroutine());
++
++ QmpBackupTask *task = opaque;
++
++ task->result = NULL; // just to be sure
++
++ BlockBackend *blk;
++ BlockDriverState *bs = NULL;
++ const char *backup_dir = NULL;
++ Error *local_err = NULL;
++ uuid_t uuid;
++ VmaWriter *vmaw = NULL;
++ ProxmoxBackupHandle *pbs = NULL;
++ gchar **devs = NULL;
++ GList *di_list = NULL;
++ GList *l;
++ UuidInfo *uuid_info;
++ BlockJob *job;
++
++ const char *config_name = "qemu-server.conf";
++ const char *firewall_name = "qemu-server.fw";
++
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
++ if (backup_state.di_list) {
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
++ "previous backup not finished");
++ return;
++ }
++
++ /* Todo: try to auto-detect format based on file name */
++ BackupFormat format = task->has_format ? task->format : BACKUP_FORMAT_VMA;
++
++ if (task->has_devlist) {
++ devs = g_strsplit_set(task->devlist, ",;:", -1);
++
++ gchar **d = devs;
++ while (d && *d) {
++ blk = blk_by_name(*d);
++ if (blk) {
++ bs = blk_bs(blk);
++ if (!bdrv_is_inserted(bs)) {
++ error_setg(task->errp, QERR_DEVICE_HAS_NO_MEDIUM, *d);
++ goto err;
++ }
++ PVEBackupDevInfo *di = g_new0(PVEBackupDevInfo, 1);
++ di->bs = bs;
++ di_list = g_list_append(di_list, di);
++ } else {
++ error_set(task->errp, ERROR_CLASS_DEVICE_NOT_FOUND,
++ "Device '%s' not found", *d);
++ goto err;
++ }
++ d++;
++ }
++
++ } else {
++ BdrvNextIterator it;
++
++ bs = NULL;
++ for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
++ if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
++ continue;
++ }
++
++ PVEBackupDevInfo *di = g_new0(PVEBackupDevInfo, 1);
++ di->bs = bs;
++ di_list = g_list_append(di_list, di);
++ }
++ }
++
++ if (!di_list) {
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "empty device list");
++ goto err;
++ }
++
++ size_t total = 0;
++
++ l = di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++ if (bdrv_op_is_blocked(di->bs, BLOCK_OP_TYPE_BACKUP_SOURCE, task->errp)) {
++ goto err;
++ }
++
++ ssize_t size = bdrv_getlength(di->bs);
++ if (size < 0) {
++ error_setg_errno(task->errp, -di->size, "bdrv_getlength failed");
++ goto err;
++ }
++ di->size = size;
++ total += size;
++ }
++
++ uuid_generate(uuid);
++
++ if (format == BACKUP_FORMAT_PBS) {
++ if (!task->has_password) {
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'password'");
++ goto err;
++ }
++ if (!task->has_backup_id) {
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-id'");
++ goto err;
++ }
++ if (!task->has_backup_time) {
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-time'");
++ goto err;
++ }
++
++ int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
++ firewall_name = "fw.conf";
++
++ char *pbs_err = NULL;
++ pbs = proxmox_backup_new(
++ task->backup_file,
++ task->backup_id,
++ task->backup_time,
++ dump_cb_block_size,
++ task->has_password ? task->password : NULL,
++ task->has_keyfile ? task->keyfile : NULL,
++ task->has_key_password ? task->key_password : NULL,
++ task->has_fingerprint ? task->fingerprint : NULL,
++ &pbs_err);
++
++ if (!pbs) {
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
++ "proxmox_backup_new failed: %s", pbs_err);
++ proxmox_backup_free_error(pbs_err);
++ goto err;
++ }
++
++ if (proxmox_backup_co_connect(pbs, task->errp) < 0)
++ goto err;
++
++ /* register all devices */
++ l = di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ const char *devname = bdrv_get_device_name(di->bs);
++
++ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, task->errp);
++ if (dev_id < 0)
++ goto err;
++
++ if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_cb, di, task->errp))) {
++ goto err;
++ }
++
++ di->dev_id = dev_id;
++ }
++ } else if (format == BACKUP_FORMAT_VMA) {
++ vmaw = vma_writer_create(task->backup_file, uuid, &local_err);
++ if (!vmaw) {
++ if (local_err) {
++ error_propagate(task->errp, local_err);
++ }
++ goto err;
++ }
++
++ /* register all devices for vma writer */
++ l = di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_cb, di, task->errp))) {
++ goto err;
++ }
++
++ const char *devname = bdrv_get_device_name(di->bs);
++ di->dev_id = vma_writer_register_stream(vmaw, devname, di->size);
++ if (di->dev_id <= 0) {
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
++ "register_stream failed");
++ goto err;
++ }
++ }
++ } else if (format == BACKUP_FORMAT_DIR) {
++ if (mkdir(task->backup_file, 0640) != 0) {
++ error_setg_errno(task->errp, errno, "can't create directory '%s'\n",
++ task->backup_file);
++ goto err;
++ }
++ backup_dir = task->backup_file;
++
++ l = di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ const char *devname = bdrv_get_device_name(di->bs);
++ snprintf(di->targetfile, PATH_MAX, "%s/%s.raw", backup_dir, devname);
++
++ int flags = BDRV_O_RDWR;
++ bdrv_img_create(di->targetfile, "raw", NULL, NULL, NULL,
++ di->size, flags, false, &local_err);
++ if (local_err) {
++ error_propagate(task->errp, local_err);
++ goto err;
++ }
++
++ di->target = bdrv_open(di->targetfile, NULL, NULL, flags, &local_err);
++ if (!di->target) {
++ error_propagate(task->errp, local_err);
++ goto err;
++ }
++ }
++ } else {
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
++ goto err;
++ }
++
++
++ /* add configuration file to archive */
++ if (task->has_config_file) {
++ if (pvebackup_co_add_config(task->config_file, config_name, format, backup_dir,
++ vmaw, pbs, task->errp) != 0) {
++ goto err;
++ }
++ }
++
++ /* add firewall file to archive */
++ if (task->has_firewall_file) {
++ if (pvebackup_co_add_config(task->firewall_file, firewall_name, format, backup_dir,
++ vmaw, pbs, task->errp) != 0) {
++ goto err;
++ }
++ }
++ /* initialize global backup_state now */
++
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++
++ backup_state.stat.cancel = false;
++
++ if (backup_state.stat.error) {
++ error_free(backup_state.stat.error);
++ backup_state.stat.error = NULL;
++ }
++
++ backup_state.stat.start_time = time(NULL);
++ backup_state.stat.end_time = 0;
++
++ if (backup_state.stat.backup_file) {
++ g_free(backup_state.stat.backup_file);
++ }
++ backup_state.stat.backup_file = g_strdup(task->backup_file);
++
++ uuid_copy(backup_state.stat.uuid, uuid);
++ uuid_unparse_lower(uuid, backup_state.stat.uuid_str);
++ char *uuid_str = g_strdup(backup_state.stat.uuid_str);
++
++ backup_state.stat.total = total;
++ backup_state.stat.transferred = 0;
++ backup_state.stat.zero_bytes = 0;
++
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ backup_state.speed = (task->has_speed && task->speed > 0) ? task->speed : 0;
++
++ backup_state.vmaw = vmaw;
++ backup_state.pbs = pbs;
++
++ backup_state.di_list = di_list;
++
++ /* start all jobs (paused state) */
++ l = di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ // make sure target runs in same aoi_context as source
++ AioContext *aio_context = bdrv_get_aio_context(di->bs);
++ aio_context_acquire(aio_context);
++ GSList *ignore = NULL;
++ bdrv_set_aio_context_ignore(di->target, aio_context, &ignore);
++ g_slist_free(ignore);
++ aio_context_release(aio_context);
++
++ job = backup_job_create(NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
++ BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
++ JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
++ if (!job || local_err != NULL) {
++ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ error_setg(&backup_state.stat.error, "backup_job_create failed");
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ break;
++ }
++ job_start(&job->job);
++ if (di->target) {
++ bdrv_unref(di->target);
++ di->target = NULL;
++ }
++ }
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ bool no_errors = !backup_state.stat.error;
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++
++ if (no_errors) {
++ pvebackup_co_run_next_job(); // run one job
++ } else {
++ pvebackup_co_cancel(NULL);
++ }
++
++ uuid_info = g_malloc0(sizeof(*uuid_info));
++ uuid_info->UUID = uuid_str;
++
++ task->result = uuid_info;
++ return;
++
++err:
++
++ l = di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ if (di->target) {
++ bdrv_unref(di->target);
++ }
++
++ if (di->targetfile[0]) {
++ unlink(di->targetfile);
++ }
++ g_free(di);
++ }
++ g_list_free(di_list);
++
++ if (devs) {
++ g_strfreev(devs);
++ }
++
++ if (vmaw) {
++ Error *err = NULL;
++ vma_writer_close(vmaw, &err);
++ unlink(task->backup_file);
++ }
++
++ if (pbs) {
++ proxmox_backup_disconnect(pbs);
++ }
++
++ if (backup_dir) {
++ rmdir(backup_dir);
++ }
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
++
++ task->result = NULL;
++ return;
++}
++
++UuidInfo *qmp_backup(
++ const char *backup_file,
++ bool has_password, const char *password,
++ bool has_keyfile, const char *keyfile,
++ bool has_key_password, const char *key_password,
++ bool has_fingerprint, const char *fingerprint,
++ bool has_backup_id, const char *backup_id,
++ bool has_backup_time, int64_t backup_time,
++ bool has_format, BackupFormat format,
++ bool has_config_file, const char *config_file,
++ bool has_firewall_file, const char *firewall_file,
++ bool has_devlist, const char *devlist,
++ bool has_speed, int64_t speed, Error **errp)
++{
++ QmpBackupTask task = {
++ .backup_file = backup_file,
++ .has_password = has_password,
++ .password = password,
++ .has_key_password = has_key_password,
++ .key_password = key_password,
++ .has_fingerprint = has_fingerprint,
++ .fingerprint = fingerprint,
++ .has_backup_id = has_backup_id,
++ .backup_id = backup_id,
++ .has_backup_time = has_backup_time,
++ .backup_time = backup_time,
++ .has_format = has_format,
++ .format = format,
++ .has_config_file = has_config_file,
++ .config_file = config_file,
++ .has_firewall_file = has_firewall_file,
++ .firewall_file = firewall_file,
++ .has_devlist = has_devlist,
++ .devlist = devlist,
++ .has_speed = has_speed,
++ .speed = speed,
++ .errp = errp,
++ };
++
++ block_on_coroutine_fn(pvebackup_co_start, &task);
++
++ return task.result;
++}
++
++
++typedef struct QmpQueryBackupTask {
++ Error **errp;
++ BackupStatus *result;
++} QmpQueryBackupTask;
++
++static void coroutine_fn pvebackup_co_query(void *opaque)
++{
++ assert(qemu_in_coroutine());
++
++ QmpQueryBackupTask *task = opaque;
++
++ BackupStatus *info = g_malloc0(sizeof(*info));
++
++ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++
++ if (!backup_state.stat.start_time) {
++ /* not started, return {} */
++ task->result = info;
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ return;
++ }
++
++ info->has_status = true;
++ info->has_start_time = true;
++ info->start_time = backup_state.stat.start_time;
++
++ if (backup_state.stat.backup_file) {
++ info->has_backup_file = true;
++ info->backup_file = g_strdup(backup_state.stat.backup_file);
++ }
++
++ info->has_uuid = true;
++ info->uuid = g_strdup(backup_state.stat.uuid_str);
++
++ if (backup_state.stat.end_time) {
++ if (backup_state.stat.error) {
++ info->status = g_strdup("error");
++ info->has_errmsg = true;
++ info->errmsg = g_strdup(error_get_pretty(backup_state.stat.error));
++ } else {
++ info->status = g_strdup("done");
++ }
++ info->has_end_time = true;
++ info->end_time = backup_state.stat.end_time;
++ } else {
++ info->status = g_strdup("active");
++ }
++
++ info->has_total = true;
++ info->total = backup_state.stat.total;
++ info->has_zero_bytes = true;
++ info->zero_bytes = backup_state.stat.zero_bytes;
++ info->has_transferred = true;
++ info->transferred = backup_state.stat.transferred;
++
++ task->result = info;
++
++ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++}
++
++BackupStatus *qmp_query_backup(Error **errp)
++{
++ QmpQueryBackupTask task = {
++ .errp = errp,
++ .result = NULL,
++ };
++
++ block_on_coroutine_fn(pvebackup_co_query, &task);
++
++ return task.result;
++}
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index ea5fae22ae..69db270b1a 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -754,6 +754,115 @@
+ { 'command': 'query-block', 'returns': ['BlockInfo'] }
+
+
++##
++# @BackupStatus:
++#
++# Detailed backup status.
++#
++# @status: string describing the current backup status.
++# This can be 'active', 'done', 'error'. If this field is not
++# returned, no backup process has been initiated
++#
++# @errmsg: error message (only returned if status is 'error')
++#
++# @total: total amount of bytes involved in the backup process
++#
++# @transferred: amount of bytes already backed up.
++#
++# @zero-bytes: amount of 'zero' bytes detected.
++#
++# @start-time: time (epoch) when backup job started.
++#
++# @end-time: time (epoch) when backup job finished.
++#
++# @backup-file: backup file name
++#
++# @uuid: uuid for this backup job
++#
++##
++{ 'struct': 'BackupStatus',
++ 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int',
++ '*transferred': 'int', '*zero-bytes': 'int',
++ '*start-time': 'int', '*end-time': 'int',
++ '*backup-file': 'str', '*uuid': 'str' } }
++
++##
++# @BackupFormat:
++#
++# An enumeration of supported backup formats.
++#
++# @vma: Proxmox vma backup format
++##
++{ 'enum': 'BackupFormat',
++ 'data': [ 'vma', 'dir', 'pbs' ] }
++
++##
++# @backup:
++#
++# Starts a VM backup.
++#
++# @backup-file: the backup file name
++#
++# @format: format of the backup file
++#
++# @config-file: a configuration file to include into
++# the backup archive.
++#
++# @speed: the maximum speed, in bytes per second
++#
++# @devlist: list of block device names (separated by ',', ';'
++# or ':'). By default the backup includes all writable block devices.
++#
++# @password: backup server passsword (required for format 'pbs')
++#
++# @keyfile: keyfile used for encryption (optional for format 'pbs')
++#
++# @key-password: password for keyfile (optional for format 'pbs')
++#
++# @fingerprint: server cert fingerprint (optional for format 'pbs')
++#
++# @backup-id: backup ID (required for format 'pbs')
++#
++# @backup-time: backup timestamp (Unix epoch, required for format 'pbs')
++#
++# Returns: the uuid of the backup job
++#
++##
++{ 'command': 'backup', 'data': { 'backup-file': 'str',
++ '*password': 'str',
++ '*keyfile': 'str',
++ '*key-password': 'str',
++ '*fingerprint': 'str',
++ '*backup-id': 'str',
++ '*backup-time': 'int',
++ '*format': 'BackupFormat',
++ '*config-file': 'str',
++ '*firewall-file': 'str',
++ '*devlist': 'str', '*speed': 'int' },
++ 'returns': 'UuidInfo' }
++
++##
++# @query-backup:
++#
++# Returns information about current/last backup task.
++#
++# Returns: @BackupStatus
++#
++##
++{ 'command': 'query-backup', 'returns': 'BackupStatus' }
++
++##
++# @backup-cancel:
++#
++# Cancel the current executing backup process.
++#
++# Returns: nothing on success
++#
++# Notes: This command succeeds even if there is no backup process running.
++#
++##
++{ 'command': 'backup-cancel' }
++
+ ##
+ # @BlockDeviceTimedStats:
+ #
+diff --git a/qapi/common.json b/qapi/common.json
+index 716712d4b3..556dab79e1 100644
+--- a/qapi/common.json
++++ b/qapi/common.json
+@@ -145,3 +145,16 @@
+ ##
+ { 'enum': 'PCIELinkWidth',
+ 'data': [ '1', '2', '4', '8', '12', '16', '32' ] }
++
++##
++# @UuidInfo:
++#
++# Guest UUID information (Universally Unique Identifier).
++#
++# @UUID: the UUID of the guest
++#
++# Since: 0.14.0
++#
++# Notes: If no UUID was specified for the guest, a null UUID is returned.
++##
++{ 'struct': 'UuidInfo', 'data': {'UUID': 'str'} }
+diff --git a/qapi/misc.json b/qapi/misc.json
+index 9895899f8b..75dff1b306 100644
+--- a/qapi/misc.json
++++ b/qapi/misc.json
+@@ -130,19 +130,6 @@
+ ##
+ { 'command': 'query-kvm', 'returns': 'KvmInfo' }
+
+-##
+-# @UuidInfo:
+-#
+-# Guest UUID information (Universally Unique Identifier).
+-#
+-# @UUID: the UUID of the guest
+-#
+-# Since: 0.14.0
+-#
+-# Notes: If no UUID was specified for the guest, a null UUID is returned.
+-##
+-{ 'struct': 'UuidInfo', 'data': {'UUID': 'str'} }
+-
+ ##
+ # @query-uuid:
+ #
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dietmar Maurer <dietmar@proxmox.com>
+Date: Mon, 6 Apr 2020 12:17:01 +0200
+Subject: [PATCH] PVE-Backup: pbs-restore - new command to restore from proxmox
+ backup server
+
+Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
+---
+ Makefile | 4 +-
+ pbs-restore.c | 217 ++++++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 220 insertions(+), 1 deletion(-)
+ create mode 100644 pbs-restore.c
+
+diff --git a/Makefile b/Makefile
+index aec216968d..b73da29f24 100644
+--- a/Makefile
++++ b/Makefile
+@@ -479,7 +479,7 @@ dummy := $(call unnest-vars,, \
+
+ include $(SRC_PATH)/tests/Makefile.include
+
+-all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) vma$(EXESUF) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
++all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) vma$(EXESUF) pbs-restore$(EXESUF) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
+
+ qemu-version.h: FORCE
+ $(call quiet-command, \
+@@ -604,6 +604,8 @@ qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-o
+ qemu-storage-daemon$(EXESUF): qemu-storage-daemon.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(chardev-obj-y) $(io-obj-y) $(qom-obj-y) $(storage-daemon-obj-y) $(COMMON_LDADDS)
+ qemu-storage-daemon$(EXESUF): LIBS += -lproxmox_backup_qemu
+ vma$(EXESUF): vma.o vma-reader.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
++pbs-restore$(EXESUF): pbs-restore.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
++pbs-restore$(EXESUF): LIBS += -lproxmox_backup_qemu
+
+ qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
+
+diff --git a/pbs-restore.c b/pbs-restore.c
+new file mode 100644
+index 0000000000..4bf37ef1fa
+--- /dev/null
++++ b/pbs-restore.c
+@@ -0,0 +1,217 @@
++/*
++ * Qemu image restore helper for Proxmox Backup
++ *
++ * Copyright (C) 2019 Proxmox Server Solutions
++ *
++ * Authors:
++ * Dietmar Maurer (dietmar@proxmox.com)
++ *
++ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++ * See the COPYING file in the top-level directory.
++ *
++ */
++
++#include "qemu/osdep.h"
++#include <glib.h>
++#include <getopt.h>
++#include <string.h>
++
++#include "qemu-common.h"
++#include "qemu/module.h"
++#include "qemu/error-report.h"
++#include "qemu/main-loop.h"
++#include "qemu/cutils.h"
++#include "qapi/error.h"
++#include "qapi/qmp/qdict.h"
++#include "sysemu/block-backend.h"
++
++#include <proxmox-backup-qemu.h>
++
++static void help(void)
++{
++ const char *help_msg =
++ "usage: pbs-restore [--repository <repo>] snapshot archive-name target [command options]\n"
++ ;
++
++ printf("%s", help_msg);
++ exit(1);
++}
++
++typedef struct CallbackData {
++ BlockBackend *target;
++ uint64_t last_offset;
++ bool skip_zero;
++} CallbackData;
++
++static int write_callback(
++ void *callback_data_ptr,
++ uint64_t offset,
++ const unsigned char *data,
++ uint64_t data_len)
++{
++ int res = -1;
++
++ CallbackData *callback_data = (CallbackData *)callback_data_ptr;
++
++ uint64_t last_offset = callback_data->last_offset;
++ if (offset > last_offset) callback_data->last_offset = offset;
++
++ if (data == NULL) {
++ if (callback_data->skip_zero && offset > last_offset) {
++ return 0;
++ }
++ res = blk_pwrite_zeroes(callback_data->target, offset, data_len, 0);
++ } else {
++ res = blk_pwrite(callback_data->target, offset, data, data_len, 0);
++ }
++
++ if (res < 0) {
++ fprintf(stderr, "blk_pwrite failed at offset %ld length %ld (%d) - %s\n", offset, data_len, res, strerror(-res));
++ return res;
++ }
++
++ return 0;
++}
++
++int main(int argc, char **argv)
++{
++ Error *main_loop_err = NULL;
++ const char *format = "raw";
++ const char *repository = NULL;
++ const char *keyfile = NULL;
++ int verbose = false;
++ bool skip_zero = false;
++
++ error_init(argv[0]);
++
++ for (;;) {
++ static const struct option long_options[] = {
++ {"help", no_argument, 0, 'h'},
++ {"skip-zero", no_argument, 0, 'S'},
++ {"verbose", no_argument, 0, 'v'},
++ {"format", required_argument, 0, 'f'},
++ {"repository", required_argument, 0, 'r'},
++ {"keyfile", required_argument, 0, 'k'},
++ {0, 0, 0, 0}
++ };
++ int c = getopt_long(argc, argv, "hvf:r:k:", long_options, NULL);
++ if (c == -1) {
++ break;
++ }
++ switch (c) {
++ case ':':
++ fprintf(stderr, "missing argument for option '%s'\n", argv[optind - 1]);
++ return -1;
++ case '?':
++ fprintf(stderr, "unrecognized option '%s'\n", argv[optind - 1]);
++ return -1;
++ case 'f':
++ format = g_strdup(argv[optind - 1]);
++ break;
++ case 'r':
++ repository = g_strdup(argv[optind - 1]);
++ break;
++ case 'k':
++ keyfile = g_strdup(argv[optind - 1]);
++ break;
++ case 'v':
++ verbose = true;
++ break;
++ case 'S':
++ skip_zero = true;
++ break;
++ case 'h':
++ help();
++ return 0;
++ }
++ }
++
++ if (optind >= argc - 2) {
++ fprintf(stderr, "missing arguments\n");
++ help();
++ return -1;
++ }
++
++ if (repository == NULL) {
++ repository = getenv("PBS_REPOSITORY");
++ }
++
++ if (repository == NULL) {
++ fprintf(stderr, "no repository specified\n");
++ help();
++ return -1;
++ }
++
++ char *snapshot = argv[optind++];
++ char *archive_name = argv[optind++];
++ char *target = argv[optind++];
++
++ const char *password = getenv("PBS_PASSWORD");
++ const char *fingerprint = getenv("PBS_FINGERPRINT");
++ const char *key_password = getenv("PBS_ENCRYPTION_PASSWORD");
++
++ if (qemu_init_main_loop(&main_loop_err)) {
++ g_error("%s", error_get_pretty(main_loop_err));
++ }
++
++ bdrv_init();
++ module_call_init(MODULE_INIT_QOM);
++
++ if (verbose) {
++ fprintf(stderr, "connecting to repository '%s'\n", repository);
++ }
++ char *pbs_error = NULL;
++ ProxmoxRestoreHandle *conn = proxmox_restore_connect(
++ repository, snapshot, password, keyfile, key_password, fingerprint, &pbs_error);
++ if (conn == NULL) {
++ fprintf(stderr, "restore failed: %s\n", pbs_error);
++ return -1;
++ }
++
++ QDict *options = qdict_new();
++
++ if (format) {
++ qdict_put_str(options, "driver", format);
++ }
++
++
++ if (verbose) {
++ fprintf(stderr, "open block backend for target '%s'\n", target);
++ }
++ Error *local_err = NULL;
++ int flags = BDRV_O_RDWR;
++ BlockBackend *blk = blk_new_open(target, NULL, options, flags, &local_err);
++ if (!blk) {
++ fprintf(stderr, "%s\n", error_get_pretty(local_err));
++ return -1;
++ }
++
++ CallbackData *callback_data = calloc(sizeof(CallbackData), 1);
++
++ callback_data->target = blk;
++ callback_data->skip_zero = skip_zero;
++ callback_data->last_offset = 0;
++
++ // blk_set_enable_write_cache(blk, !writethrough);
++
++ if (verbose) {
++ fprintf(stderr, "starting to restore snapshot '%s'\n", snapshot);
++ fflush(stderr); // ensure we do not get printed after the progress log
++ }
++ int res = proxmox_restore_image(
++ conn,
++ archive_name,
++ write_callback,
++ callback_data,
++ &pbs_error,
++ verbose);
++
++ proxmox_restore_disconnect(conn);
++
++ if (res < 0) {
++ fprintf(stderr, "restore failed: %s\n", pbs_error);
++ return -1;
++ }
++
++ return 0;
++}
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Dietmar Maurer <dietmar@proxmox.com>
-Date: Mon, 6 Apr 2020 12:16:59 +0200
-Subject: [PATCH] PVE-Backup: proxmox backup patches for qemu
-
----
- Makefile | 1 +
- Makefile.objs | 2 +
- Makefile.target | 2 +-
- block/monitor/block-hmp-cmds.c | 33 ++
- blockdev.c | 1 +
- hmp-commands-info.hx | 13 +
- hmp-commands.hx | 29 +
- include/block/block_int.h | 2 +-
- include/monitor/hmp.h | 3 +
- monitor/hmp-cmds.c | 44 ++
- proxmox-backup-client.c | 182 +++++++
- proxmox-backup-client.h | 52 ++
- pve-backup.c | 959 +++++++++++++++++++++++++++++++++
- qapi/block-core.json | 109 ++++
- qapi/common.json | 13 +
- qapi/misc.json | 13 -
- 16 files changed, 1443 insertions(+), 15 deletions(-)
- create mode 100644 proxmox-backup-client.c
- create mode 100644 proxmox-backup-client.h
- create mode 100644 pve-backup.c
-
-diff --git a/Makefile b/Makefile
-index 7b8c17ce2d..aec216968d 100644
---- a/Makefile
-+++ b/Makefile
-@@ -602,6 +602,7 @@ qemu-img$(EXESUF): qemu-img.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io
- qemu-nbd$(EXESUF): qemu-nbd.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
- qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
- qemu-storage-daemon$(EXESUF): qemu-storage-daemon.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(chardev-obj-y) $(io-obj-y) $(qom-obj-y) $(storage-daemon-obj-y) $(COMMON_LDADDS)
-+qemu-storage-daemon$(EXESUF): LIBS += -lproxmox_backup_qemu
- vma$(EXESUF): vma.o vma-reader.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
-
- qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
-diff --git a/Makefile.objs b/Makefile.objs
-index ade7b17a69..240eb503f2 100644
---- a/Makefile.objs
-+++ b/Makefile.objs
-@@ -33,6 +33,7 @@ endif # CONFIG_SOFTMMU or CONFIG_TOOLS
-
- storage-daemon-obj-y = block/ monitor/ qapi/ qom/ storage-daemon/
- storage-daemon-obj-y += blockdev.o blockdev-nbd.o iothread.o job-qmp.o
-+storage-daemon-obj-y += proxmox-backup-client.o pve-backup.o
- storage-daemon-obj-$(CONFIG_WIN32) += os-win32.o
- storage-daemon-obj-$(CONFIG_POSIX) += os-posix.o
-
-@@ -44,6 +45,7 @@ storage-daemon-obj-$(CONFIG_POSIX) += os-posix.o
- ifeq ($(CONFIG_SOFTMMU),y)
- common-obj-y = blockdev.o blockdev-nbd.o block/
- common-obj-y += bootdevice.o iothread.o
-+common-obj-y += proxmox-backup-client.o pve-backup.o
- common-obj-y += dump/
- common-obj-y += job-qmp.o
- common-obj-y += monitor/
-diff --git a/Makefile.target b/Makefile.target
-index ffa2657269..fd3fd6d2a7 100644
---- a/Makefile.target
-+++ b/Makefile.target
-@@ -159,7 +159,7 @@ obj-y += hw/
- obj-y += monitor/
- obj-y += qapi/
- obj-y += migration/ram.o
--LIBS := $(libs_softmmu) $(LIBS)
-+LIBS := $(libs_softmmu) $(LIBS) -lproxmox_backup_qemu
-
- # Hardware support
- ifeq ($(TARGET_NAME), sparc64)
-diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
-index 4c8c375172..d485c3ac79 100644
---- a/block/monitor/block-hmp-cmds.c
-+++ b/block/monitor/block-hmp-cmds.c
-@@ -1011,3 +1011,36 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
- g_free(sn_tab);
- g_free(global_snapshots);
- }
-+
-+void hmp_backup_cancel(Monitor *mon, const QDict *qdict)
-+{
-+ Error *error = NULL;
-+
-+ qmp_backup_cancel(&error);
-+
-+ hmp_handle_error(mon, error);
-+}
-+
-+void hmp_backup(Monitor *mon, const QDict *qdict)
-+{
-+ Error *error = NULL;
-+
-+ int dir = qdict_get_try_bool(qdict, "directory", 0);
-+ const char *backup_file = qdict_get_str(qdict, "backupfile");
-+ const char *devlist = qdict_get_try_str(qdict, "devlist");
-+ int64_t speed = qdict_get_try_int(qdict, "speed", 0);
-+
-+ qmp_backup(
-+ backup_file,
-+ false, NULL, // PBS password
-+ false, NULL, // PBS keyfile
-+ false, NULL, // PBS key_password
-+ false, NULL, // PBS fingerprint
-+ false, NULL, // PBS backup-id
-+ false, 0, // PBS backup-time
-+ true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
-+ false, NULL, false, NULL, !!devlist,
-+ devlist, qdict_haskey(qdict, "speed"), speed, &error);
-+
-+ hmp_handle_error(mon, error);
-+}
-diff --git a/blockdev.c b/blockdev.c
-index 5107c5445e..3c427fc4be 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -36,6 +36,7 @@
- #include "hw/block/block.h"
- #include "block/blockjob.h"
- #include "block/qdict.h"
-+#include "block/blockjob_int.h"
- #include "block/throttle-groups.h"
- #include "monitor/monitor.h"
- #include "qemu/error-report.h"
-diff --git a/hmp-commands-info.hx b/hmp-commands-info.hx
-index ae8ff21789..da16499f8d 100644
---- a/hmp-commands-info.hx
-+++ b/hmp-commands-info.hx
-@@ -513,6 +513,19 @@ SRST
- Show CPU statistics.
- ERST
-
-+ {
-+ .name = "backup",
-+ .args_type = "",
-+ .params = "",
-+ .help = "show backup status",
-+ .cmd = hmp_info_backup,
-+ },
-+
-+SRST
-+ ``info backup``
-+ Show backup status.
-+ERST
-+
- #if defined(CONFIG_SLIRP)
- {
- .name = "usernet",
-diff --git a/hmp-commands.hx b/hmp-commands.hx
-index 2b58ac4a1c..9e58b6a5fc 100644
---- a/hmp-commands.hx
-+++ b/hmp-commands.hx
-@@ -97,6 +97,35 @@ ERST
- SRST
- ``block_stream``
- Copy data from a backing file into a block device.
-+ERST
-+
-+ {
-+ .name = "backup",
-+ .args_type = "directory:-d,backupfile:s,speed:o?,devlist:s?",
-+ .params = "[-d] backupfile [speed [devlist]]",
-+ .help = "create a VM Backup."
-+ "\n\t\t\t Use -d to dump data into a directory instead"
-+ "\n\t\t\t of using VMA format.",
-+ .cmd = hmp_backup,
-+ },
-+
-+SRST
-+``backup``
-+ Create a VM backup.
-+ERST
-+
-+ {
-+ .name = "backup_cancel",
-+ .args_type = "",
-+ .params = "",
-+ .help = "cancel the current VM backup",
-+ .cmd = hmp_backup_cancel,
-+ },
-+
-+SRST
-+``backup_cancel``
-+ Cancel the current VM backup.
-+
- ERST
-
- {
-diff --git a/include/block/block_int.h b/include/block/block_int.h
-index dc72197388..5ff3b1186f 100644
---- a/include/block/block_int.h
-+++ b/include/block/block_int.h
-@@ -64,7 +64,7 @@
-
- typedef int BackupDumpFunc(void *opaque, uint64_t offset, uint64_t bytes, const void *buf);
-
--BlockDriverState *bdrv_backuo_dump_create(
-+BlockDriverState *bdrv_backup_dump_create(
- int dump_cb_block_size,
- uint64_t byte_size,
- BackupDumpFunc *dump_cb,
-diff --git a/include/monitor/hmp.h b/include/monitor/hmp.h
-index 243952d32f..892a6064be 100644
---- a/include/monitor/hmp.h
-+++ b/include/monitor/hmp.h
-@@ -30,6 +30,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict);
- void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict);
- void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict);
- void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict);
-+void hmp_info_backup(Monitor *mon, const QDict *qdict);
- void hmp_info_cpus(Monitor *mon, const QDict *qdict);
- void hmp_info_vnc(Monitor *mon, const QDict *qdict);
- void hmp_info_spice(Monitor *mon, const QDict *qdict);
-@@ -76,6 +77,8 @@ void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict);
- void hmp_set_password(Monitor *mon, const QDict *qdict);
- void hmp_expire_password(Monitor *mon, const QDict *qdict);
- void hmp_change(Monitor *mon, const QDict *qdict);
-+void hmp_backup(Monitor *mon, const QDict *qdict);
-+void hmp_backup_cancel(Monitor *mon, const QDict *qdict);
- void hmp_migrate(Monitor *mon, const QDict *qdict);
- void hmp_device_add(Monitor *mon, const QDict *qdict);
- void hmp_device_del(Monitor *mon, const QDict *qdict);
-diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
-index 280bb447a6..0e2d166552 100644
---- a/monitor/hmp-cmds.c
-+++ b/monitor/hmp-cmds.c
-@@ -192,6 +192,50 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
- qapi_free_MouseInfoList(mice_list);
- }
-
-+void hmp_info_backup(Monitor *mon, const QDict *qdict)
-+{
-+ BackupStatus *info;
-+
-+ info = qmp_query_backup(NULL);
-+
-+ if (!info) {
-+ monitor_printf(mon, "Backup status: not initialized\n");
-+ return;
-+ }
-+
-+ if (info->has_status) {
-+ if (info->has_errmsg) {
-+ monitor_printf(mon, "Backup status: %s - %s\n",
-+ info->status, info->errmsg);
-+ } else {
-+ monitor_printf(mon, "Backup status: %s\n", info->status);
-+ }
-+ }
-+
-+ if (info->has_backup_file) {
-+ monitor_printf(mon, "Start time: %s", ctime(&info->start_time));
-+ if (info->end_time) {
-+ monitor_printf(mon, "End time: %s", ctime(&info->end_time));
-+ }
-+
-+ int per = (info->has_total && info->total &&
-+ info->has_transferred && info->transferred) ?
-+ (info->transferred * 100)/info->total : 0;
-+ int zero_per = (info->has_total && info->total &&
-+ info->has_zero_bytes && info->zero_bytes) ?
-+ (info->zero_bytes * 100)/info->total : 0;
-+ monitor_printf(mon, "Backup file: %s\n", info->backup_file);
-+ monitor_printf(mon, "Backup uuid: %s\n", info->uuid);
-+ monitor_printf(mon, "Total size: %zd\n", info->total);
-+ monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
-+ info->transferred, per);
-+ monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
-+ info->zero_bytes, zero_per);
-+ }
-+
-+ qapi_free_BackupStatus(info);
-+}
-+
- static char *SocketAddress_to_str(SocketAddress *addr)
- {
- switch (addr->type) {
-diff --git a/proxmox-backup-client.c b/proxmox-backup-client.c
-new file mode 100644
-index 0000000000..b7bc7f2574
---- /dev/null
-+++ b/proxmox-backup-client.c
-@@ -0,0 +1,182 @@
-+#include "proxmox-backup-client.h"
-+#include "qemu/main-loop.h"
-+#include "block/aio-wait.h"
-+#include "qapi/error.h"
-+
-+/* Proxmox Backup Server client bindings using coroutines */
-+
-+typedef struct BlockOnCoroutineWrapper {
-+ AioContext *ctx;
-+ CoroutineEntry *entry;
-+ void *entry_arg;
-+ bool finished;
-+} BlockOnCoroutineWrapper;
-+
-+// Waker implementaion to syncronice with proxmox backup rust code
-+typedef struct ProxmoxBackupWaker {
-+ Coroutine *co;
-+ AioContext *ctx;
-+} ProxmoxBackupWaker;
-+
-+static void coroutine_fn block_on_coroutine_wrapper(void *opaque)
-+{
-+ BlockOnCoroutineWrapper *wrapper = opaque;
-+ wrapper->entry(wrapper->entry_arg);
-+ wrapper->finished = true;
-+ aio_wait_kick();
-+}
-+
-+void block_on_coroutine_fn(CoroutineEntry *entry, void *entry_arg)
-+{
-+ assert(!qemu_in_coroutine());
-+
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ BlockOnCoroutineWrapper wrapper = {
-+ .finished = false,
-+ .entry = entry,
-+ .entry_arg = entry_arg,
-+ .ctx = ctx,
-+ };
-+ Coroutine *wrapper_co = qemu_coroutine_create(block_on_coroutine_wrapper, &wrapper);
-+ aio_co_enter(ctx, wrapper_co);
-+ AIO_WAIT_WHILE(ctx, !wrapper.finished);
-+}
-+
-+// This is called from another thread, so we use aio_co_schedule()
-+static void proxmox_backup_schedule_wake(void *data) {
-+ ProxmoxBackupWaker *waker = (ProxmoxBackupWaker *)data;
-+ aio_co_schedule(waker->ctx, waker->co);
-+}
-+
-+int coroutine_fn
-+proxmox_backup_co_connect(ProxmoxBackupHandle *pbs, Error **errp)
-+{
-+ Coroutine *co = qemu_coroutine_self();
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
-+ char *pbs_err = NULL;
-+ int pbs_res = -1;
-+
-+ proxmox_backup_connect_async(pbs, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
-+ qemu_coroutine_yield();
-+ if (pbs_res < 0) {
-+ if (errp) error_setg(errp, "backup connect failed: %s", pbs_err ? pbs_err : "unknown error");
-+ if (pbs_err) proxmox_backup_free_error(pbs_err);
-+ }
-+ return pbs_res;
-+}
-+
-+int coroutine_fn
-+proxmox_backup_co_add_config(
-+ ProxmoxBackupHandle *pbs,
-+ const char *name,
-+ const uint8_t *data,
-+ uint64_t size,
-+ Error **errp)
-+{
-+ Coroutine *co = qemu_coroutine_self();
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
-+ char *pbs_err = NULL;
-+ int pbs_res = -1;
-+
-+ proxmox_backup_add_config_async(
-+ pbs, name, data, size ,proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
-+ qemu_coroutine_yield();
-+ if (pbs_res < 0) {
-+ if (errp) error_setg(errp, "backup add_config %s failed: %s", name, pbs_err ? pbs_err : "unknown error");
-+ if (pbs_err) proxmox_backup_free_error(pbs_err);
-+ }
-+ return pbs_res;
-+}
-+
-+int coroutine_fn
-+proxmox_backup_co_register_image(
-+ ProxmoxBackupHandle *pbs,
-+ const char *device_name,
-+ uint64_t size,
-+ Error **errp)
-+{
-+ Coroutine *co = qemu_coroutine_self();
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
-+ char *pbs_err = NULL;
-+ int pbs_res = -1;
-+
-+ proxmox_backup_register_image_async(
-+ pbs, device_name, size ,proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
-+ qemu_coroutine_yield();
-+ if (pbs_res < 0) {
-+ if (errp) error_setg(errp, "backup register image failed: %s", pbs_err ? pbs_err : "unknown error");
-+ if (pbs_err) proxmox_backup_free_error(pbs_err);
-+ }
-+ return pbs_res;
-+}
-+
-+int coroutine_fn
-+proxmox_backup_co_finish(
-+ ProxmoxBackupHandle *pbs,
-+ Error **errp)
-+{
-+ Coroutine *co = qemu_coroutine_self();
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
-+ char *pbs_err = NULL;
-+ int pbs_res = -1;
-+
-+ proxmox_backup_finish_async(
-+ pbs, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
-+ qemu_coroutine_yield();
-+ if (pbs_res < 0) {
-+ if (errp) error_setg(errp, "backup finish failed: %s", pbs_err ? pbs_err : "unknown error");
-+ if (pbs_err) proxmox_backup_free_error(pbs_err);
-+ }
-+ return pbs_res;
-+}
-+
-+int coroutine_fn
-+proxmox_backup_co_close_image(
-+ ProxmoxBackupHandle *pbs,
-+ uint8_t dev_id,
-+ Error **errp)
-+{
-+ Coroutine *co = qemu_coroutine_self();
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
-+ char *pbs_err = NULL;
-+ int pbs_res = -1;
-+
-+ proxmox_backup_close_image_async(
-+ pbs, dev_id, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
-+ qemu_coroutine_yield();
-+ if (pbs_res < 0) {
-+ if (errp) error_setg(errp, "backup close image failed: %s", pbs_err ? pbs_err : "unknown error");
-+ if (pbs_err) proxmox_backup_free_error(pbs_err);
-+ }
-+ return pbs_res;
-+}
-+
-+int coroutine_fn
-+proxmox_backup_co_write_data(
-+ ProxmoxBackupHandle *pbs,
-+ uint8_t dev_id,
-+ const uint8_t *data,
-+ uint64_t offset,
-+ uint64_t size,
-+ Error **errp)
-+{
-+ Coroutine *co = qemu_coroutine_self();
-+ AioContext *ctx = qemu_get_current_aio_context();
-+ ProxmoxBackupWaker waker = { .co = co, .ctx = ctx };
-+ char *pbs_err = NULL;
-+ int pbs_res = -1;
-+
-+ proxmox_backup_write_data_async(
-+ pbs, dev_id, data, offset, size, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
-+ qemu_coroutine_yield();
-+ if (pbs_res < 0) {
-+ if (errp) error_setg(errp, "backup write data failed: %s", pbs_err ? pbs_err : "unknown error");
-+ if (pbs_err) proxmox_backup_free_error(pbs_err);
-+ }
-+ return pbs_res;
-+}
-diff --git a/proxmox-backup-client.h b/proxmox-backup-client.h
-new file mode 100644
-index 0000000000..b311bf8de8
---- /dev/null
-+++ b/proxmox-backup-client.h
-@@ -0,0 +1,52 @@
-+#ifndef PROXMOX_BACKUP_CLIENT_H
-+#define PROXMOX_BACKUP_CLIENT_H
-+
-+#include "qemu/osdep.h"
-+#include "qemu/coroutine.h"
-+#include "proxmox-backup-qemu.h"
-+
-+void block_on_coroutine_fn(CoroutineEntry *entry, void *entry_arg);
-+
-+int coroutine_fn
-+proxmox_backup_co_connect(
-+ ProxmoxBackupHandle *pbs,
-+ Error **errp);
-+
-+int coroutine_fn
-+proxmox_backup_co_add_config(
-+ ProxmoxBackupHandle *pbs,
-+ const char *name,
-+ const uint8_t *data,
-+ uint64_t size,
-+ Error **errp);
-+
-+int coroutine_fn
-+proxmox_backup_co_register_image(
-+ ProxmoxBackupHandle *pbs,
-+ const char *device_name,
-+ uint64_t size,
-+ Error **errp);
-+
-+
-+int coroutine_fn
-+proxmox_backup_co_finish(
-+ ProxmoxBackupHandle *pbs,
-+ Error **errp);
-+
-+int coroutine_fn
-+proxmox_backup_co_close_image(
-+ ProxmoxBackupHandle *pbs,
-+ uint8_t dev_id,
-+ Error **errp);
-+
-+int coroutine_fn
-+proxmox_backup_co_write_data(
-+ ProxmoxBackupHandle *pbs,
-+ uint8_t dev_id,
-+ const uint8_t *data,
-+ uint64_t offset,
-+ uint64_t size,
-+ Error **errp);
-+
-+
-+#endif /* PROXMOX_BACKUP_CLIENT_H */
-diff --git a/pve-backup.c b/pve-backup.c
-new file mode 100644
-index 0000000000..9ae89fb679
---- /dev/null
-+++ b/pve-backup.c
-@@ -0,0 +1,955 @@
-+#include "proxmox-backup-client.h"
-+#include "vma.h"
-+
-+#include "qemu/osdep.h"
-+#include "qemu/module.h"
-+#include "sysemu/block-backend.h"
-+#include "sysemu/blockdev.h"
-+#include "block/blockjob.h"
-+#include "qapi/qapi-commands-block.h"
-+#include "qapi/qmp/qerror.h"
-+
-+/* PVE backup state and related function */
-+
-+
-+static struct PVEBackupState {
-+ struct {
-+ // Everithing accessed from qmp command, protected using rwlock
-+ CoRwlock rwlock;
-+ Error *error;
-+ time_t start_time;
-+ time_t end_time;
-+ char *backup_file;
-+ uuid_t uuid;
-+ char uuid_str[37];
-+ size_t total;
-+ size_t transferred;
-+ size_t zero_bytes;
-+ bool cancel;
-+ } stat;
-+ int64_t speed;
-+ VmaWriter *vmaw;
-+ ProxmoxBackupHandle *pbs;
-+ GList *di_list;
-+ CoMutex backup_mutex;
-+} backup_state;
-+
-+static void pvebackup_init(void)
-+{
-+ qemu_co_rwlock_init(&backup_state.stat.rwlock);
-+ qemu_co_mutex_init(&backup_state.backup_mutex);
-+}
-+
-+// initialize PVEBackupState at startup
-+opts_init(pvebackup_init);
-+
-+typedef struct PVEBackupDevInfo {
-+ BlockDriverState *bs;
-+ size_t size;
-+ uint8_t dev_id;
-+ bool completed;
-+ char targetfile[PATH_MAX];
-+ BlockDriverState *target;
-+} PVEBackupDevInfo;
-+
-+static void pvebackup_co_run_next_job(void);
-+
-+static int coroutine_fn
-+pvebackup_co_dump_cb(
-+ void *opaque,
-+ uint64_t start,
-+ uint64_t bytes,
-+ const void *pbuf)
-+{
-+ assert(qemu_in_coroutine());
-+
-+ const uint64_t size = bytes;
-+ const unsigned char *buf = pbuf;
-+ PVEBackupDevInfo *di = opaque;
-+
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ bool cancel = backup_state.stat.cancel;
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ if (cancel) {
-+ return size; // return success
-+ }
-+
-+ qemu_co_mutex_lock(&backup_state.backup_mutex);
-+
-+ int ret = -1;
-+
-+ if (backup_state.vmaw) {
-+ size_t zero_bytes = 0;
-+ uint64_t remaining = size;
-+
-+ uint64_t cluster_num = start / VMA_CLUSTER_SIZE;
-+ if ((cluster_num * VMA_CLUSTER_SIZE) != start) {
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ if (!backup_state.stat.error) {
-+ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-+ error_setg(&backup_state.stat.error,
-+ "got unaligned write inside backup dump "
-+ "callback (sector %ld)", start);
-+ }
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ return -1; // not aligned to cluster size
-+ }
-+
-+ while (remaining > 0) {
-+ ret = vma_writer_write(backup_state.vmaw, di->dev_id, cluster_num,
-+ buf, &zero_bytes);
-+ ++cluster_num;
-+ if (buf) {
-+ buf += VMA_CLUSTER_SIZE;
-+ }
-+ if (ret < 0) {
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ if (!backup_state.stat.error) {
-+ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-+ vma_writer_error_propagate(backup_state.vmaw, &backup_state.stat.error);
-+ }
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ return ret;
-+ } else {
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ backup_state.stat.zero_bytes += zero_bytes;
-+ if (remaining >= VMA_CLUSTER_SIZE) {
-+ backup_state.stat.transferred += VMA_CLUSTER_SIZE;
-+ remaining -= VMA_CLUSTER_SIZE;
-+ } else {
-+ backup_state.stat.transferred += remaining;
-+ remaining = 0;
-+ }
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ }
-+ }
-+ } else if (backup_state.pbs) {
-+ Error *local_err = NULL;
-+ int pbs_res = -1;
-+
-+ pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
-+
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+
-+ if (pbs_res < 0) {
-+ error_propagate(&backup_state.stat.error, local_err);
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ return pbs_res;
-+ } else {
-+ if (!buf) {
-+ backup_state.stat.zero_bytes += size;
-+ }
-+ backup_state.stat.transferred += size;
-+ }
-+
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ } else {
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ if (!buf) {
-+ backup_state.stat.zero_bytes += size;
-+ }
-+ backup_state.stat.transferred += size;
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ }
-+
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+
-+ return size;
-+}
-+
-+static void coroutine_fn pvebackup_co_cleanup(void)
-+{
-+ assert(qemu_in_coroutine());
-+
-+ qemu_co_mutex_lock(&backup_state.backup_mutex);
-+
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ backup_state.stat.end_time = time(NULL);
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ if (backup_state.vmaw) {
-+ Error *local_err = NULL;
-+ vma_writer_close(backup_state.vmaw, &local_err);
-+
-+ if (local_err != NULL) {
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ error_propagate(&backup_state.stat.error, local_err);
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ }
-+
-+ backup_state.vmaw = NULL;
-+ }
-+
-+ if (backup_state.pbs) {
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
-+ if (!error_or_canceled) {
-+ Error *local_err = NULL;
-+ proxmox_backup_co_finish(backup_state.pbs, &local_err);
-+ if (local_err != NULL) {
-+ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-+ error_propagate(&backup_state.stat.error, local_err);
-+ }
-+ }
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ proxmox_backup_disconnect(backup_state.pbs);
-+ backup_state.pbs = NULL;
-+ }
-+
-+ g_list_free(backup_state.di_list);
-+ backup_state.di_list = NULL;
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+}
-+
-+typedef struct PVEBackupCompeteCallbackData {
-+ PVEBackupDevInfo *di;
-+ int result;
-+} PVEBackupCompeteCallbackData;
-+
-+static void coroutine_fn pvebackup_co_complete_cb(void *opaque)
-+{
-+ assert(qemu_in_coroutine());
-+
-+ PVEBackupCompeteCallbackData *cb_data = opaque;
-+
-+ qemu_co_mutex_lock(&backup_state.backup_mutex);
-+
-+ PVEBackupDevInfo *di = cb_data->di;
-+ int ret = cb_data->result;
-+
-+ di->completed = true;
-+
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
-+
-+ if (ret < 0 && !backup_state.stat.error) {
-+ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-+ error_setg(&backup_state.stat.error, "job failed with err %d - %s",
-+ ret, strerror(-ret));
-+ }
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ di->bs = NULL;
-+
-+ if (di->target) {
-+ bdrv_unref(di->target);
-+ di->target = NULL;
-+ }
-+
-+ if (backup_state.vmaw) {
-+ vma_writer_close_stream(backup_state.vmaw, di->dev_id);
-+ }
-+
-+ if (backup_state.pbs && !error_or_canceled) {
-+ Error *local_err = NULL;
-+ proxmox_backup_co_close_image(backup_state.pbs, di->dev_id, &local_err);
-+ if (local_err != NULL) {
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ error_propagate(&backup_state.stat.error, local_err);
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ }
-+ }
-+
-+ // remove self from job queue
-+ backup_state.di_list = g_list_remove(backup_state.di_list, di);
-+ g_free(di);
-+
-+ int pending_jobs = g_list_length(backup_state.di_list);
-+
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+
-+ if (pending_jobs > 0) {
-+ pvebackup_co_run_next_job();
-+ } else {
-+ pvebackup_co_cleanup();
-+ }
-+}
-+
-+static void pvebackup_complete_cb(void *opaque, int ret)
-+{
-+ // This can be called from the main loop, or from a coroutine
-+ PVEBackupCompeteCallbackData cb_data = {
-+ .di = opaque,
-+ .result = ret,
-+ };
-+
-+ if (qemu_in_coroutine()) {
-+ pvebackup_co_complete_cb(&cb_data);
-+ } else {
-+ block_on_coroutine_fn(pvebackup_co_complete_cb, &cb_data);
-+ }
-+}
-+
-+static void coroutine_fn pvebackup_co_cancel(void *opaque)
-+{
-+ assert(qemu_in_coroutine());
-+
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ backup_state.stat.cancel = true;
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ qemu_co_mutex_lock(&backup_state.backup_mutex);
-+
-+ // Avoid race between block jobs and backup-cancel command:
-+ if (!(backup_state.vmaw || backup_state.pbs)) {
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ return;
-+ }
-+
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ if (!backup_state.stat.error) {
-+ qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-+ error_setg(&backup_state.stat.error, "backup cancelled");
-+ }
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ if (backup_state.vmaw) {
-+ /* make sure vma writer does not block anymore */
-+ vma_writer_set_error(backup_state.vmaw, "backup cancelled");
-+ }
-+
-+ if (backup_state.pbs) {
-+ proxmox_backup_abort(backup_state.pbs, "backup cancelled");
-+ }
-+
-+ bool running_jobs = 0;
-+ GList *l = backup_state.di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+ if (!di->completed && di->bs) {
-+ for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
-+ if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
-+ continue;
-+ }
-+
-+ BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
-+ if (bjob && bjob->source_bs == di->bs) {
-+ AioContext *aio_context = job->job.aio_context;
-+ aio_context_acquire(aio_context);
-+
-+ if (!di->completed) {
-+ running_jobs += 1;
-+ job_cancel(&job->job, false);
-+ }
-+ aio_context_release(aio_context);
-+ }
-+ }
-+ }
-+ }
-+
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+
-+ if (running_jobs == 0) pvebackup_co_cleanup(); // else job will call completion handler
-+}
-+
-+void qmp_backup_cancel(Error **errp)
-+{
-+ block_on_coroutine_fn(pvebackup_co_cancel, NULL);
-+}
-+
-+static int coroutine_fn pvebackup_co_add_config(
-+ const char *file,
-+ const char *name,
-+ BackupFormat format,
-+ const char *backup_dir,
-+ VmaWriter *vmaw,
-+ ProxmoxBackupHandle *pbs,
-+ Error **errp)
-+{
-+ int res = 0;
-+
-+ char *cdata = NULL;
-+ gsize clen = 0;
-+ GError *err = NULL;
-+ if (!g_file_get_contents(file, &cdata, &clen, &err)) {
-+ error_setg(errp, "unable to read file '%s'", file);
-+ return 1;
-+ }
-+
-+ char *basename = g_path_get_basename(file);
-+ if (name == NULL) name = basename;
-+
-+ if (format == BACKUP_FORMAT_VMA) {
-+ if (vma_writer_add_config(vmaw, name, cdata, clen) != 0) {
-+ error_setg(errp, "unable to add %s config data to vma archive", file);
-+ goto err;
-+ }
-+ } else if (format == BACKUP_FORMAT_PBS) {
-+ if (proxmox_backup_co_add_config(pbs, name, (unsigned char *)cdata, clen, errp) < 0)
-+ goto err;
-+ } else if (format == BACKUP_FORMAT_DIR) {
-+ char config_path[PATH_MAX];
-+ snprintf(config_path, PATH_MAX, "%s/%s", backup_dir, name);
-+ if (!g_file_set_contents(config_path, cdata, clen, &err)) {
-+ error_setg(errp, "unable to write config file '%s'", config_path);
-+ goto err;
-+ }
-+ }
-+
-+ out:
-+ g_free(basename);
-+ g_free(cdata);
-+ return res;
-+
-+ err:
-+ res = -1;
-+ goto out;
-+}
-+
-+bool job_should_pause(Job *job);
-+
-+static void coroutine_fn pvebackup_co_run_next_job(void)
-+{
-+ assert(qemu_in_coroutine());
-+
-+ qemu_co_mutex_lock(&backup_state.backup_mutex);
-+
-+ GList *l = backup_state.di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+ if (!di->completed && di->bs) {
-+ for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
-+ if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
-+ continue;
-+ }
-+
-+ BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
-+ if (bjob && bjob->source_bs == di->bs) {
-+ AioContext *aio_context = job->job.aio_context;
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ aio_context_acquire(aio_context);
-+
-+ if (job_should_pause(&job->job)) {
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ if (error_or_canceled) {
-+ job_cancel(&job->job, false);
-+ } else {
-+ job_resume(&job->job);
-+ }
-+ }
-+ aio_context_release(aio_context);
-+ return;
-+ }
-+ }
-+ }
-+ }
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+}
-+
-+typedef struct QmpBackupTask {
-+ const char *backup_file;
-+ bool has_password;
-+ const char *password;
-+ bool has_keyfile;
-+ const char *keyfile;
-+ bool has_key_password;
-+ const char *key_password;
-+ bool has_backup_id;
-+ const char *backup_id;
-+ bool has_backup_time;
-+ const char *fingerprint;
-+ bool has_fingerprint;
-+ int64_t backup_time;
-+ bool has_format;
-+ BackupFormat format;
-+ bool has_config_file;
-+ const char *config_file;
-+ bool has_firewall_file;
-+ const char *firewall_file;
-+ bool has_devlist;
-+ const char *devlist;
-+ bool has_speed;
-+ int64_t speed;
-+ Error **errp;
-+ UuidInfo *result;
-+} QmpBackupTask;
-+
-+static void coroutine_fn pvebackup_co_start(void *opaque)
-+{
-+ assert(qemu_in_coroutine());
-+
-+ QmpBackupTask *task = opaque;
-+
-+ task->result = NULL; // just to be sure
-+
-+ BlockBackend *blk;
-+ BlockDriverState *bs = NULL;
-+ const char *backup_dir = NULL;
-+ Error *local_err = NULL;
-+ uuid_t uuid;
-+ VmaWriter *vmaw = NULL;
-+ ProxmoxBackupHandle *pbs = NULL;
-+ gchar **devs = NULL;
-+ GList *di_list = NULL;
-+ GList *l;
-+ UuidInfo *uuid_info;
-+ BlockJob *job;
-+
-+ const char *config_name = "qemu-server.conf";
-+ const char *firewall_name = "qemu-server.fw";
-+
-+ qemu_co_mutex_lock(&backup_state.backup_mutex);
-+
-+ if (backup_state.di_list) {
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
-+ "previous backup not finished");
-+ return;
-+ }
-+
-+ /* Todo: try to auto-detect format based on file name */
-+ BackupFormat format = task->has_format ? task->format : BACKUP_FORMAT_VMA;
-+
-+ if (task->has_devlist) {
-+ devs = g_strsplit_set(task->devlist, ",;:", -1);
-+
-+ gchar **d = devs;
-+ while (d && *d) {
-+ blk = blk_by_name(*d);
-+ if (blk) {
-+ bs = blk_bs(blk);
-+ if (!bdrv_is_inserted(bs)) {
-+ error_setg(task->errp, QERR_DEVICE_HAS_NO_MEDIUM, *d);
-+ goto err;
-+ }
-+ PVEBackupDevInfo *di = g_new0(PVEBackupDevInfo, 1);
-+ di->bs = bs;
-+ di_list = g_list_append(di_list, di);
-+ } else {
-+ error_set(task->errp, ERROR_CLASS_DEVICE_NOT_FOUND,
-+ "Device '%s' not found", *d);
-+ goto err;
-+ }
-+ d++;
-+ }
-+
-+ } else {
-+ BdrvNextIterator it;
-+
-+ bs = NULL;
-+ for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
-+ if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
-+ continue;
-+ }
-+
-+ PVEBackupDevInfo *di = g_new0(PVEBackupDevInfo, 1);
-+ di->bs = bs;
-+ di_list = g_list_append(di_list, di);
-+ }
-+ }
-+
-+ if (!di_list) {
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "empty device list");
-+ goto err;
-+ }
-+
-+ size_t total = 0;
-+
-+ l = di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+ if (bdrv_op_is_blocked(di->bs, BLOCK_OP_TYPE_BACKUP_SOURCE, task->errp)) {
-+ goto err;
-+ }
-+
-+ ssize_t size = bdrv_getlength(di->bs);
-+ if (size < 0) {
-+ error_setg_errno(task->errp, -di->size, "bdrv_getlength failed");
-+ goto err;
-+ }
-+ di->size = size;
-+ total += size;
-+ }
-+
-+ uuid_generate(uuid);
-+
-+ if (format == BACKUP_FORMAT_PBS) {
-+ if (!task->has_password) {
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'password'");
-+ goto err;
-+ }
-+ if (!task->has_backup_id) {
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-id'");
-+ goto err;
-+ }
-+ if (!task->has_backup_time) {
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-time'");
-+ goto err;
-+ }
-+
-+ int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
-+ firewall_name = "fw.conf";
-+
-+ char *pbs_err = NULL;
-+ pbs = proxmox_backup_new(
-+ task->backup_file,
-+ task->backup_id,
-+ task->backup_time,
-+ dump_cb_block_size,
-+ task->has_password ? task->password : NULL,
-+ task->has_keyfile ? task->keyfile : NULL,
-+ task->has_key_password ? task->key_password : NULL,
-+ task->has_fingerprint ? task->fingerprint : NULL,
-+ &pbs_err);
-+
-+ if (!pbs) {
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
-+ "proxmox_backup_new failed: %s", pbs_err);
-+ proxmox_backup_free_error(pbs_err);
-+ goto err;
-+ }
-+
-+ if (proxmox_backup_co_connect(pbs, task->errp) < 0)
-+ goto err;
-+
-+ /* register all devices */
-+ l = di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ const char *devname = bdrv_get_device_name(di->bs);
-+
-+ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, task->errp);
-+ if (dev_id < 0)
-+ goto err;
-+
-+ if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_cb, di, task->errp))) {
-+ goto err;
-+ }
-+
-+ di->dev_id = dev_id;
-+ }
-+ } else if (format == BACKUP_FORMAT_VMA) {
-+ vmaw = vma_writer_create(task->backup_file, uuid, &local_err);
-+ if (!vmaw) {
-+ if (local_err) {
-+ error_propagate(task->errp, local_err);
-+ }
-+ goto err;
-+ }
-+
-+ /* register all devices for vma writer */
-+ l = di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_cb, di, task->errp))) {
-+ goto err;
-+ }
-+
-+ const char *devname = bdrv_get_device_name(di->bs);
-+ di->dev_id = vma_writer_register_stream(vmaw, devname, di->size);
-+ if (di->dev_id <= 0) {
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
-+ "register_stream failed");
-+ goto err;
-+ }
-+ }
-+ } else if (format == BACKUP_FORMAT_DIR) {
-+ if (mkdir(task->backup_file, 0640) != 0) {
-+ error_setg_errno(task->errp, errno, "can't create directory '%s'\n",
-+ task->backup_file);
-+ goto err;
-+ }
-+ backup_dir = task->backup_file;
-+
-+ l = di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ const char *devname = bdrv_get_device_name(di->bs);
-+ snprintf(di->targetfile, PATH_MAX, "%s/%s.raw", backup_dir, devname);
-+
-+ int flags = BDRV_O_RDWR;
-+ bdrv_img_create(di->targetfile, "raw", NULL, NULL, NULL,
-+ di->size, flags, false, &local_err);
-+ if (local_err) {
-+ error_propagate(task->errp, local_err);
-+ goto err;
-+ }
-+
-+ di->target = bdrv_open(di->targetfile, NULL, NULL, flags, &local_err);
-+ if (!di->target) {
-+ error_propagate(task->errp, local_err);
-+ goto err;
-+ }
-+ }
-+ } else {
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
-+ goto err;
-+ }
-+
-+
-+ /* add configuration file to archive */
-+ if (task->has_config_file) {
-+ if (pvebackup_co_add_config(task->config_file, config_name, format, backup_dir,
-+ vmaw, pbs, task->errp) != 0) {
-+ goto err;
-+ }
-+ }
-+
-+ /* add firewall file to archive */
-+ if (task->has_firewall_file) {
-+ if (pvebackup_co_add_config(task->firewall_file, firewall_name, format, backup_dir,
-+ vmaw, pbs, task->errp) != 0) {
-+ goto err;
-+ }
-+ }
-+ /* initialize global backup_state now */
-+
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+
-+ backup_state.stat.cancel = false;
-+
-+ if (backup_state.stat.error) {
-+ error_free(backup_state.stat.error);
-+ backup_state.stat.error = NULL;
-+ }
-+
-+ backup_state.stat.start_time = time(NULL);
-+ backup_state.stat.end_time = 0;
-+
-+ if (backup_state.stat.backup_file) {
-+ g_free(backup_state.stat.backup_file);
-+ }
-+ backup_state.stat.backup_file = g_strdup(task->backup_file);
-+
-+ uuid_copy(backup_state.stat.uuid, uuid);
-+ uuid_unparse_lower(uuid, backup_state.stat.uuid_str);
-+ char *uuid_str = g_strdup(backup_state.stat.uuid_str);
-+
-+ backup_state.stat.total = total;
-+ backup_state.stat.transferred = 0;
-+ backup_state.stat.zero_bytes = 0;
-+
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ backup_state.speed = (task->has_speed && task->speed > 0) ? task->speed : 0;
-+
-+ backup_state.vmaw = vmaw;
-+ backup_state.pbs = pbs;
-+
-+ backup_state.di_list = di_list;
-+
-+ /* start all jobs (paused state) */
-+ l = di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ // make sure target runs in same aoi_context as source
-+ AioContext *aio_context = bdrv_get_aio_context(di->bs);
-+ aio_context_acquire(aio_context);
-+ GSList *ignore = NULL;
-+ bdrv_set_aio_context_ignore(di->target, aio_context, &ignore);
-+ g_slist_free(ignore);
-+ aio_context_release(aio_context);
-+
-+ job = backup_job_create(NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
-+ BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
-+ JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
-+ if (!job || local_err != NULL) {
-+ qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ error_setg(&backup_state.stat.error, "backup_job_create failed");
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ break;
-+ }
-+ job_start(&job->job);
-+ if (di->target) {
-+ bdrv_unref(di->target);
-+ di->target = NULL;
-+ }
-+ }
-+
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ bool no_errors = !backup_state.stat.error;
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+
-+ if (no_errors) {
-+ pvebackup_co_run_next_job(); // run one job
-+ } else {
-+ pvebackup_co_cancel(NULL);
-+ }
-+
-+ uuid_info = g_malloc0(sizeof(*uuid_info));
-+ uuid_info->UUID = uuid_str;
-+
-+ task->result = uuid_info;
-+ return;
-+
-+err:
-+
-+ l = di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ if (di->target) {
-+ bdrv_unref(di->target);
-+ }
-+
-+ if (di->targetfile[0]) {
-+ unlink(di->targetfile);
-+ }
-+ g_free(di);
-+ }
-+ g_list_free(di_list);
-+
-+ if (devs) {
-+ g_strfreev(devs);
-+ }
-+
-+ if (vmaw) {
-+ Error *err = NULL;
-+ vma_writer_close(vmaw, &err);
-+ unlink(task->backup_file);
-+ }
-+
-+ if (pbs) {
-+ proxmox_backup_disconnect(pbs);
-+ }
-+
-+ if (backup_dir) {
-+ rmdir(backup_dir);
-+ }
-+
-+ qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+
-+ task->result = NULL;
-+ return;
-+}
-+
-+UuidInfo *qmp_backup(
-+ const char *backup_file,
-+ bool has_password, const char *password,
-+ bool has_keyfile, const char *keyfile,
-+ bool has_key_password, const char *key_password,
-+ bool has_fingerprint, const char *fingerprint,
-+ bool has_backup_id, const char *backup_id,
-+ bool has_backup_time, int64_t backup_time,
-+ bool has_format, BackupFormat format,
-+ bool has_config_file, const char *config_file,
-+ bool has_firewall_file, const char *firewall_file,
-+ bool has_devlist, const char *devlist,
-+ bool has_speed, int64_t speed, Error **errp)
-+{
-+ QmpBackupTask task = {
-+ .backup_file = backup_file,
-+ .has_password = has_password,
-+ .password = password,
-+ .has_key_password = has_key_password,
-+ .key_password = key_password,
-+ .has_fingerprint = has_fingerprint,
-+ .fingerprint = fingerprint,
-+ .has_backup_id = has_backup_id,
-+ .backup_id = backup_id,
-+ .has_backup_time = has_backup_time,
-+ .backup_time = backup_time,
-+ .has_format = has_format,
-+ .format = format,
-+ .has_config_file = has_config_file,
-+ .config_file = config_file,
-+ .has_firewall_file = has_firewall_file,
-+ .firewall_file = firewall_file,
-+ .has_devlist = has_devlist,
-+ .devlist = devlist,
-+ .has_speed = has_speed,
-+ .speed = speed,
-+ .errp = errp,
-+ };
-+
-+ block_on_coroutine_fn(pvebackup_co_start, &task);
-+
-+ return task.result;
-+}
-+
-+
-+typedef struct QmpQueryBackupTask {
-+ Error **errp;
-+ BackupStatus *result;
-+} QmpQueryBackupTask;
-+
-+static void coroutine_fn pvebackup_co_query(void *opaque)
-+{
-+ assert(qemu_in_coroutine());
-+
-+ QmpQueryBackupTask *task = opaque;
-+
-+ BackupStatus *info = g_malloc0(sizeof(*info));
-+
-+ qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+
-+ if (!backup_state.stat.start_time) {
-+ /* not started, return {} */
-+ task->result = info;
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ return;
-+ }
-+
-+ info->has_status = true;
-+ info->has_start_time = true;
-+ info->start_time = backup_state.stat.start_time;
-+
-+ if (backup_state.stat.backup_file) {
-+ info->has_backup_file = true;
-+ info->backup_file = g_strdup(backup_state.stat.backup_file);
-+ }
-+
-+ info->has_uuid = true;
-+ info->uuid = g_strdup(backup_state.stat.uuid_str);
-+
-+ if (backup_state.stat.end_time) {
-+ if (backup_state.stat.error) {
-+ info->status = g_strdup("error");
-+ info->has_errmsg = true;
-+ info->errmsg = g_strdup(error_get_pretty(backup_state.stat.error));
-+ } else {
-+ info->status = g_strdup("done");
-+ }
-+ info->has_end_time = true;
-+ info->end_time = backup_state.stat.end_time;
-+ } else {
-+ info->status = g_strdup("active");
-+ }
-+
-+ info->has_total = true;
-+ info->total = backup_state.stat.total;
-+ info->has_zero_bytes = true;
-+ info->zero_bytes = backup_state.stat.zero_bytes;
-+ info->has_transferred = true;
-+ info->transferred = backup_state.stat.transferred;
-+
-+ task->result = info;
-+
-+ qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+}
-+
-+BackupStatus *qmp_query_backup(Error **errp)
-+{
-+ QmpQueryBackupTask task = {
-+ .errp = errp,
-+ .result = NULL,
-+ };
-+
-+ block_on_coroutine_fn(pvebackup_co_query, &task);
-+
-+ return task.result;
-+}
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index ea5fae22ae..69db270b1a 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -754,6 +754,115 @@
- { 'command': 'query-block', 'returns': ['BlockInfo'] }
-
-
-+##
-+# @BackupStatus:
-+#
-+# Detailed backup status.
-+#
-+# @status: string describing the current backup status.
-+# This can be 'active', 'done', 'error'. If this field is not
-+# returned, no backup process has been initiated
-+#
-+# @errmsg: error message (only returned if status is 'error')
-+#
-+# @total: total amount of bytes involved in the backup process
-+#
-+# @transferred: amount of bytes already backed up.
-+#
-+# @zero-bytes: amount of 'zero' bytes detected.
-+#
-+# @start-time: time (epoch) when backup job started.
-+#
-+# @end-time: time (epoch) when backup job finished.
-+#
-+# @backup-file: backup file name
-+#
-+# @uuid: uuid for this backup job
-+#
-+##
-+{ 'struct': 'BackupStatus',
-+ 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int',
-+ '*transferred': 'int', '*zero-bytes': 'int',
-+ '*start-time': 'int', '*end-time': 'int',
-+ '*backup-file': 'str', '*uuid': 'str' } }
-+
-+##
-+# @BackupFormat:
-+#
-+# An enumeration of supported backup formats.
-+#
-+# @vma: Proxmox vma backup format
-+##
-+{ 'enum': 'BackupFormat',
-+ 'data': [ 'vma', 'dir', 'pbs' ] }
-+
-+##
-+# @backup:
-+#
-+# Starts a VM backup.
-+#
-+# @backup-file: the backup file name
-+#
-+# @format: format of the backup file
-+#
-+# @config-file: a configuration file to include into
-+# the backup archive.
-+#
-+# @speed: the maximum speed, in bytes per second
-+#
-+# @devlist: list of block device names (separated by ',', ';'
-+# or ':'). By default the backup includes all writable block devices.
-+#
-+# @password: backup server passsword (required for format 'pbs')
-+#
-+# @keyfile: keyfile used for encryption (optional for format 'pbs')
-+#
-+# @key-password: password for keyfile (optional for format 'pbs')
-+#
-+# @fingerprint: server cert fingerprint (optional for format 'pbs')
-+#
-+# @backup-id: backup ID (required for format 'pbs')
-+#
-+# @backup-time: backup timestamp (Unix epoch, required for format 'pbs')
-+#
-+# Returns: the uuid of the backup job
-+#
-+##
-+{ 'command': 'backup', 'data': { 'backup-file': 'str',
-+ '*password': 'str',
-+ '*keyfile': 'str',
-+ '*key-password': 'str',
-+ '*fingerprint': 'str',
-+ '*backup-id': 'str',
-+ '*backup-time': 'int',
-+ '*format': 'BackupFormat',
-+ '*config-file': 'str',
-+ '*firewall-file': 'str',
-+ '*devlist': 'str', '*speed': 'int' },
-+ 'returns': 'UuidInfo' }
-+
-+##
-+# @query-backup:
-+#
-+# Returns information about current/last backup task.
-+#
-+# Returns: @BackupStatus
-+#
-+##
-+{ 'command': 'query-backup', 'returns': 'BackupStatus' }
-+
-+##
-+# @backup-cancel:
-+#
-+# Cancel the current executing backup process.
-+#
-+# Returns: nothing on success
-+#
-+# Notes: This command succeeds even if there is no backup process running.
-+#
-+##
-+{ 'command': 'backup-cancel' }
-+
- ##
- # @BlockDeviceTimedStats:
- #
-diff --git a/qapi/common.json b/qapi/common.json
-index 716712d4b3..556dab79e1 100644
---- a/qapi/common.json
-+++ b/qapi/common.json
-@@ -145,3 +145,16 @@
- ##
- { 'enum': 'PCIELinkWidth',
- 'data': [ '1', '2', '4', '8', '12', '16', '32' ] }
-+
-+##
-+# @UuidInfo:
-+#
-+# Guest UUID information (Universally Unique Identifier).
-+#
-+# @UUID: the UUID of the guest
-+#
-+# Since: 0.14.0
-+#
-+# Notes: If no UUID was specified for the guest, a null UUID is returned.
-+##
-+{ 'struct': 'UuidInfo', 'data': {'UUID': 'str'} }
-diff --git a/qapi/misc.json b/qapi/misc.json
-index 9895899f8b..75dff1b306 100644
---- a/qapi/misc.json
-+++ b/qapi/misc.json
-@@ -130,19 +130,6 @@
- ##
- { 'command': 'query-kvm', 'returns': 'KvmInfo' }
-
--##
--# @UuidInfo:
--#
--# Guest UUID information (Universally Unique Identifier).
--#
--# @UUID: the UUID of the guest
--#
--# Since: 0.14.0
--#
--# Notes: If no UUID was specified for the guest, a null UUID is returned.
--##
--{ 'struct': 'UuidInfo', 'data': {'UUID': 'str'} }
--
- ##
- # @query-uuid:
- #
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dietmar Maurer <dietmar@proxmox.com>
+Date: Mon, 6 Apr 2020 12:17:00 +0200
+Subject: [PATCH] PVE-Backup: avoid coroutines to fix AIO freeze, cleanups
+
+We observed various AIO pool loop freezes, so we decided to avoid
+coroutines and restrict ourselfes using similar code as upstream
+(see blockdev.c: do_backup_common).
+
+* avoid coroutine for job related code (causes hangs with iothreads)
+ - We then acquire/release all mutexes outside coroutines now, so we can now
+ correctly use a normal mutex.
+
+* split pvebackup_co_dump_cb into:
+ - pvebackup_co_dump_pbs_cb and
+ - pvebackup_co_dump_pbs_cb
+
+* new helper functions
+ - pvebackup_propagate_error
+ - pvebackup_error_or_canceled
+ - pvebackup_add_transfered_bytes
+
+* avoid cancel flag (not needed)
+
+* simplify backup_cancel logic
+
+There is progress on upstream to support running qmp commands inside
+coroutines, see:
+https://lists.gnu.org/archive/html/qemu-devel/2020-02/msg04852.html
+
+We should consider using that when it is available in upstream qemu.
+
+Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
+---
+ pve-backup.c | 638 ++++++++++++++++++++++++++-------------------------
+ 1 file changed, 320 insertions(+), 318 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 55441eb9d1..d40f3f2fd6 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -11,11 +11,27 @@
+
+ /* PVE backup state and related function */
+
++/*
++ * Note: A resume from a qemu_coroutine_yield can happen in a different thread,
++ * so you may not use normal mutexes within coroutines:
++ *
++ * ---bad-example---
++ * qemu_rec_mutex_lock(lock)
++ * ...
++ * qemu_coroutine_yield() // wait for something
++ * // we are now inside a different thread
++ * qemu_rec_mutex_unlock(lock) // Crash - wrong thread!!
++ * ---end-bad-example--
++ *
++ * ==> Always use CoMutext inside coroutines.
++ * ==> Never acquire/release AioContext withing coroutines (because that use QemuRecMutex)
++ *
++ */
+
+ static struct PVEBackupState {
+ struct {
+- // Everithing accessed from qmp command, protected using rwlock
+- CoRwlock rwlock;
++ // Everithing accessed from qmp_backup_query command is protected using lock
++ QemuMutex lock;
+ Error *error;
+ time_t start_time;
+ time_t end_time;
+@@ -25,19 +41,20 @@ static struct PVEBackupState {
+ size_t total;
+ size_t transferred;
+ size_t zero_bytes;
+- bool cancel;
+ } stat;
+ int64_t speed;
+ VmaWriter *vmaw;
+ ProxmoxBackupHandle *pbs;
+ GList *di_list;
+- CoMutex backup_mutex;
++ QemuMutex backup_mutex;
++ CoMutex dump_callback_mutex;
+ } backup_state;
+
+ static void pvebackup_init(void)
+ {
+- qemu_co_rwlock_init(&backup_state.stat.rwlock);
+- qemu_co_mutex_init(&backup_state.backup_mutex);
++ qemu_mutex_init(&backup_state.stat.lock);
++ qemu_mutex_init(&backup_state.backup_mutex);
++ qemu_co_mutex_init(&backup_state.dump_callback_mutex);
+ }
+
+ // initialize PVEBackupState at startup
+@@ -52,10 +69,54 @@ typedef struct PVEBackupDevInfo {
+ BlockDriverState *target;
+ } PVEBackupDevInfo;
+
+-static void pvebackup_co_run_next_job(void);
++static void pvebackup_run_next_job(void);
+
++static BlockJob *
++lookup_active_block_job(PVEBackupDevInfo *di)
++{
++ if (!di->completed && di->bs) {
++ for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
++ if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
++ continue;
++ }
++
++ BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
++ if (bjob && bjob->source_bs == di->bs) {
++ return job;
++ }
++ }
++ }
++ return NULL;
++}
++
++static void pvebackup_propagate_error(Error *err)
++{
++ qemu_mutex_lock(&backup_state.stat.lock);
++ error_propagate(&backup_state.stat.error, err);
++ qemu_mutex_unlock(&backup_state.stat.lock);
++}
++
++static bool pvebackup_error_or_canceled(void)
++{
++ qemu_mutex_lock(&backup_state.stat.lock);
++ bool error_or_canceled = !!backup_state.stat.error;
++ qemu_mutex_unlock(&backup_state.stat.lock);
++
++ return error_or_canceled;
++}
++
++static void pvebackup_add_transfered_bytes(size_t transferred, size_t zero_bytes)
++{
++ qemu_mutex_lock(&backup_state.stat.lock);
++ backup_state.stat.zero_bytes += zero_bytes;
++ backup_state.stat.transferred += transferred;
++ qemu_mutex_unlock(&backup_state.stat.lock);
++}
++
++// This may get called from multiple coroutines in multiple io-threads
++// Note1: this may get called after job_cancel()
+ static int coroutine_fn
+-pvebackup_co_dump_cb(
++pvebackup_co_dump_pbs_cb(
+ void *opaque,
+ uint64_t start,
+ uint64_t bytes,
+@@ -67,137 +128,127 @@ pvebackup_co_dump_cb(
+ const unsigned char *buf = pbuf;
+ PVEBackupDevInfo *di = opaque;
+
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- bool cancel = backup_state.stat.cancel;
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ assert(backup_state.pbs);
++
++ Error *local_err = NULL;
++ int pbs_res = -1;
++
++ qemu_co_mutex_lock(&backup_state.dump_callback_mutex);
+
+- if (cancel) {
+- return size; // return success
++ // avoid deadlock if job is cancelled
++ if (pvebackup_error_or_canceled()) {
++ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
++ return -1;
+ }
+
+- qemu_co_mutex_lock(&backup_state.backup_mutex);
++ pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
++ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
+
+- int ret = -1;
++ if (pbs_res < 0) {
++ pvebackup_propagate_error(local_err);
++ return pbs_res;
++ } else {
++ pvebackup_add_transfered_bytes(size, !buf ? size : 0);
++ }
+
+- if (backup_state.vmaw) {
+- size_t zero_bytes = 0;
+- uint64_t remaining = size;
+-
+- uint64_t cluster_num = start / VMA_CLUSTER_SIZE;
+- if ((cluster_num * VMA_CLUSTER_SIZE) != start) {
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- if (!backup_state.stat.error) {
+- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
+- error_setg(&backup_state.stat.error,
+- "got unaligned write inside backup dump "
+- "callback (sector %ld)", start);
+- }
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+- return -1; // not aligned to cluster size
+- }
++ return size;
++}
+
+- while (remaining > 0) {
+- ret = vma_writer_write(backup_state.vmaw, di->dev_id, cluster_num,
+- buf, &zero_bytes);
+- ++cluster_num;
+- if (buf) {
+- buf += VMA_CLUSTER_SIZE;
+- }
+- if (ret < 0) {
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- if (!backup_state.stat.error) {
+- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
+- vma_writer_error_propagate(backup_state.vmaw, &backup_state.stat.error);
+- }
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++// This may get called from multiple coroutines in multiple io-threads
++static int coroutine_fn
++pvebackup_co_dump_vma_cb(
++ void *opaque,
++ uint64_t start,
++ uint64_t bytes,
++ const void *pbuf)
++{
++ assert(qemu_in_coroutine());
+
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+- return ret;
+- } else {
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
+- backup_state.stat.zero_bytes += zero_bytes;
+- if (remaining >= VMA_CLUSTER_SIZE) {
+- backup_state.stat.transferred += VMA_CLUSTER_SIZE;
+- remaining -= VMA_CLUSTER_SIZE;
+- } else {
+- backup_state.stat.transferred += remaining;
+- remaining = 0;
+- }
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+- }
+- }
+- } else if (backup_state.pbs) {
+- Error *local_err = NULL;
+- int pbs_res = -1;
++ const uint64_t size = bytes;
++ const unsigned char *buf = pbuf;
++ PVEBackupDevInfo *di = opaque;
+
+- pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
++ int ret = -1;
+
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ assert(backup_state.vmaw);
+
+- if (pbs_res < 0) {
+- error_propagate(&backup_state.stat.error, local_err);
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+- return pbs_res;
+- } else {
+- if (!buf) {
+- backup_state.stat.zero_bytes += size;
+- }
+- backup_state.stat.transferred += size;
++ uint64_t remaining = size;
++
++ uint64_t cluster_num = start / VMA_CLUSTER_SIZE;
++ if ((cluster_num * VMA_CLUSTER_SIZE) != start) {
++ Error *local_err = NULL;
++ error_setg(&local_err,
++ "got unaligned write inside backup dump "
++ "callback (sector %ld)", start);
++ pvebackup_propagate_error(local_err);
++ return -1; // not aligned to cluster size
++ }
++
++ while (remaining > 0) {
++ qemu_co_mutex_lock(&backup_state.dump_callback_mutex);
++ // avoid deadlock if job is cancelled
++ if (pvebackup_error_or_canceled()) {
++ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
++ return -1;
+ }
+
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ size_t zero_bytes = 0;
++ ret = vma_writer_write(backup_state.vmaw, di->dev_id, cluster_num, buf, &zero_bytes);
++ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
+
+- } else {
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
+- if (!buf) {
+- backup_state.stat.zero_bytes += size;
++ ++cluster_num;
++ if (buf) {
++ buf += VMA_CLUSTER_SIZE;
++ }
++ if (ret < 0) {
++ Error *local_err = NULL;
++ vma_writer_error_propagate(backup_state.vmaw, &local_err);
++ pvebackup_propagate_error(local_err);
++ return ret;
++ } else {
++ if (remaining >= VMA_CLUSTER_SIZE) {
++ assert(ret == VMA_CLUSTER_SIZE);
++ pvebackup_add_transfered_bytes(VMA_CLUSTER_SIZE, zero_bytes);
++ remaining -= VMA_CLUSTER_SIZE;
++ } else {
++ assert(ret == remaining);
++ pvebackup_add_transfered_bytes(remaining, zero_bytes);
++ remaining = 0;
++ }
+ }
+- backup_state.stat.transferred += size;
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+ }
+
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+-
+ return size;
+ }
+
+-static void coroutine_fn pvebackup_co_cleanup(void)
++// assumes the caller holds backup_mutex
++static void coroutine_fn pvebackup_co_cleanup(void *unused)
+ {
+ assert(qemu_in_coroutine());
+
+- qemu_co_mutex_lock(&backup_state.backup_mutex);
+-
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
++ qemu_mutex_lock(&backup_state.stat.lock);
+ backup_state.stat.end_time = time(NULL);
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ qemu_mutex_unlock(&backup_state.stat.lock);
+
+ if (backup_state.vmaw) {
+ Error *local_err = NULL;
+ vma_writer_close(backup_state.vmaw, &local_err);
+
+ if (local_err != NULL) {
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
+- error_propagate(&backup_state.stat.error, local_err);
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+- }
++ pvebackup_propagate_error(local_err);
++ }
+
+ backup_state.vmaw = NULL;
+ }
+
+ if (backup_state.pbs) {
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
+- if (!error_or_canceled) {
++ if (!pvebackup_error_or_canceled()) {
+ Error *local_err = NULL;
+ proxmox_backup_co_finish(backup_state.pbs, &local_err);
+ if (local_err != NULL) {
+- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
+- error_propagate(&backup_state.stat.error, local_err);
+- }
++ pvebackup_propagate_error(local_err);
++ }
+ }
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+
+ proxmox_backup_disconnect(backup_state.pbs);
+ backup_state.pbs = NULL;
+@@ -205,43 +256,14 @@ static void coroutine_fn pvebackup_co_cleanup(void)
+
+ g_list_free(backup_state.di_list);
+ backup_state.di_list = NULL;
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+ }
+
+-typedef struct PVEBackupCompeteCallbackData {
+- PVEBackupDevInfo *di;
+- int result;
+-} PVEBackupCompeteCallbackData;
+-
+-static void coroutine_fn pvebackup_co_complete_cb(void *opaque)
++// assumes the caller holds backup_mutex
++static void coroutine_fn pvebackup_complete_stream(void *opaque)
+ {
+- assert(qemu_in_coroutine());
+-
+- PVEBackupCompeteCallbackData *cb_data = opaque;
+-
+- qemu_co_mutex_lock(&backup_state.backup_mutex);
+-
+- PVEBackupDevInfo *di = cb_data->di;
+- int ret = cb_data->result;
+-
+- di->completed = true;
+-
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
+-
+- if (ret < 0 && !backup_state.stat.error) {
+- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
+- error_setg(&backup_state.stat.error, "job failed with err %d - %s",
+- ret, strerror(-ret));
+- }
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+-
+- di->bs = NULL;
++ PVEBackupDevInfo *di = opaque;
+
+- if (di->target) {
+- bdrv_unref(di->target);
+- di->target = NULL;
+- }
++ bool error_or_canceled = pvebackup_error_or_canceled();
+
+ if (backup_state.vmaw) {
+ vma_writer_close_stream(backup_state.vmaw, di->dev_id);
+@@ -251,110 +273,101 @@ static void coroutine_fn pvebackup_co_complete_cb(void *opaque)
+ Error *local_err = NULL;
+ proxmox_backup_co_close_image(backup_state.pbs, di->dev_id, &local_err);
+ if (local_err != NULL) {
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
+- error_propagate(&backup_state.stat.error, local_err);
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ pvebackup_propagate_error(local_err);
+ }
+ }
++}
+
+- // remove self from job queue
+- backup_state.di_list = g_list_remove(backup_state.di_list, di);
+- g_free(di);
++static void pvebackup_complete_cb(void *opaque, int ret)
++{
++ assert(!qemu_in_coroutine());
+
+- int pending_jobs = g_list_length(backup_state.di_list);
++ PVEBackupDevInfo *di = opaque;
+
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ qemu_mutex_lock(&backup_state.backup_mutex);
+
+- if (pending_jobs > 0) {
+- pvebackup_co_run_next_job();
+- } else {
+- pvebackup_co_cleanup();
++ di->completed = true;
++
++ if (ret < 0) {
++ Error *local_err = NULL;
++ error_setg(&local_err, "job failed with err %d - %s", ret, strerror(-ret));
++ pvebackup_propagate_error(local_err);
+ }
+-}
+
+-static void pvebackup_complete_cb(void *opaque, int ret)
+-{
+- // This can be called from the main loop, or from a coroutine
+- PVEBackupCompeteCallbackData cb_data = {
+- .di = opaque,
+- .result = ret,
+- };
++ di->bs = NULL;
+
+- if (qemu_in_coroutine()) {
+- pvebackup_co_complete_cb(&cb_data);
+- } else {
+- block_on_coroutine_fn(pvebackup_co_complete_cb, &cb_data);
+- }
+-}
++ assert(di->target == NULL);
+
+-static void coroutine_fn pvebackup_co_cancel(void *opaque)
+-{
+- assert(qemu_in_coroutine());
++ block_on_coroutine_fn(pvebackup_complete_stream, di);
+
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
+- backup_state.stat.cancel = true;
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ // remove self from job queue
++ backup_state.di_list = g_list_remove(backup_state.di_list, di);
+
+- qemu_co_mutex_lock(&backup_state.backup_mutex);
++ g_free(di);
+
+- // Avoid race between block jobs and backup-cancel command:
+- if (!(backup_state.vmaw || backup_state.pbs)) {
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+- return;
+- }
++ qemu_mutex_unlock(&backup_state.backup_mutex);
+
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- if (!backup_state.stat.error) {
+- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
+- error_setg(&backup_state.stat.error, "backup cancelled");
+- }
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ pvebackup_run_next_job();
++}
++
++static void pvebackup_cancel(void)
++{
++ assert(!qemu_in_coroutine());
++
++ Error *cancel_err = NULL;
++ error_setg(&cancel_err, "backup canceled");
++ pvebackup_propagate_error(cancel_err);
++
++ qemu_mutex_lock(&backup_state.backup_mutex);
+
+ if (backup_state.vmaw) {
+ /* make sure vma writer does not block anymore */
+- vma_writer_set_error(backup_state.vmaw, "backup cancelled");
++ vma_writer_set_error(backup_state.vmaw, "backup canceled");
+ }
+
+ if (backup_state.pbs) {
+- proxmox_backup_abort(backup_state.pbs, "backup cancelled");
++ proxmox_backup_abort(backup_state.pbs, "backup canceled");
+ }
+
+- bool running_jobs = 0;
+- GList *l = backup_state.di_list;
+- while (l) {
+- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+- l = g_list_next(l);
+- if (!di->completed && di->bs) {
+- for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
+- if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
+- continue;
+- }
++ qemu_mutex_unlock(&backup_state.backup_mutex);
+
+- BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
+- if (bjob && bjob->source_bs == di->bs) {
+- AioContext *aio_context = job->job.aio_context;
+- aio_context_acquire(aio_context);
++ for(;;) {
+
+- if (!di->completed) {
+- running_jobs += 1;
+- job_cancel(&job->job, false);
+- }
+- aio_context_release(aio_context);
+- }
++ BlockJob *next_job = NULL;
++
++ qemu_mutex_lock(&backup_state.backup_mutex);
++
++ GList *l = backup_state.di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ BlockJob *job = lookup_active_block_job(di);
++ if (job != NULL) {
++ next_job = job;
++ break;
+ }
+ }
+- }
+
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
++ qemu_mutex_unlock(&backup_state.backup_mutex);
+
+- if (running_jobs == 0) pvebackup_co_cleanup(); // else job will call completion handler
++ if (next_job) {
++ AioContext *aio_context = next_job->job.aio_context;
++ aio_context_acquire(aio_context);
++ job_cancel_sync(&next_job->job);
++ aio_context_release(aio_context);
++ } else {
++ break;
++ }
++ }
+ }
+
+ void qmp_backup_cancel(Error **errp)
+ {
+- block_on_coroutine_fn(pvebackup_co_cancel, NULL);
++ pvebackup_cancel();
+ }
+
++// assumes the caller holds backup_mutex
+ static int coroutine_fn pvebackup_co_add_config(
+ const char *file,
+ const char *name,
+@@ -406,46 +419,97 @@ static int coroutine_fn pvebackup_co_add_config(
+
+ bool job_should_pause(Job *job);
+
+-static void coroutine_fn pvebackup_co_run_next_job(void)
++static void pvebackup_run_next_job(void)
+ {
+- assert(qemu_in_coroutine());
++ assert(!qemu_in_coroutine());
+
+- qemu_co_mutex_lock(&backup_state.backup_mutex);
++ qemu_mutex_lock(&backup_state.backup_mutex);
+
+ GList *l = backup_state.di_list;
+ while (l) {
+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+ l = g_list_next(l);
+- if (!di->completed && di->bs) {
+- for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
+- if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
+- continue;
+- }
+
+- BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
+- if (bjob && bjob->source_bs == di->bs) {
+- AioContext *aio_context = job->job.aio_context;
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+- aio_context_acquire(aio_context);
+-
+- if (job_should_pause(&job->job)) {
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+-
+- if (error_or_canceled) {
+- job_cancel(&job->job, false);
+- } else {
+- job_resume(&job->job);
+- }
+- }
+- aio_context_release(aio_context);
+- return;
++ BlockJob *job = lookup_active_block_job(di);
++
++ if (job) {
++ qemu_mutex_unlock(&backup_state.backup_mutex);
++
++ AioContext *aio_context = job->job.aio_context;
++ aio_context_acquire(aio_context);
++
++ if (job_should_pause(&job->job)) {
++ bool error_or_canceled = pvebackup_error_or_canceled();
++ if (error_or_canceled) {
++ job_cancel_sync(&job->job);
++ } else {
++ job_resume(&job->job);
+ }
+ }
++ aio_context_release(aio_context);
++ return;
++ }
++ }
++
++ block_on_coroutine_fn(pvebackup_co_cleanup, NULL); // no more jobs, run cleanup
++
++ qemu_mutex_unlock(&backup_state.backup_mutex);
++}
++
++static bool create_backup_jobs(void) {
++
++ assert(!qemu_in_coroutine());
++
++ Error *local_err = NULL;
++
++ /* create and start all jobs (paused state) */
++ GList *l = backup_state.di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ assert(di->target != NULL);
++
++ AioContext *aio_context = bdrv_get_aio_context(di->bs);
++ aio_context_acquire(aio_context);
++
++ BlockJob *job = backup_job_create(
++ NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
++ BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
++ JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
++
++ aio_context_release(aio_context);
++
++ if (!job || local_err != NULL) {
++ Error *create_job_err = NULL;
++ error_setg(&create_job_err, "backup_job_create failed: %s",
++ local_err ? error_get_pretty(local_err) : "null");
++
++ pvebackup_propagate_error(create_job_err);
++ break;
++ }
++ job_start(&job->job);
++
++ bdrv_unref(di->target);
++ di->target = NULL;
++ }
++
++ bool errors = pvebackup_error_or_canceled();
++
++ if (errors) {
++ l = backup_state.di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ if (di->target) {
++ bdrv_unref(di->target);
++ di->target = NULL;
++ }
+ }
+ }
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
++
++ return errors;
+ }
+
+ typedef struct QmpBackupTask {
+@@ -476,7 +540,8 @@ typedef struct QmpBackupTask {
+ UuidInfo *result;
+ } QmpBackupTask;
+
+-static void coroutine_fn pvebackup_co_start(void *opaque)
++// assumes the caller holds backup_mutex
++static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ {
+ assert(qemu_in_coroutine());
+
+@@ -495,16 +560,12 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
+ GList *di_list = NULL;
+ GList *l;
+ UuidInfo *uuid_info;
+- BlockJob *job;
+
+ const char *config_name = "qemu-server.conf";
+ const char *firewall_name = "qemu-server.fw";
+
+- qemu_co_mutex_lock(&backup_state.backup_mutex);
+-
+ if (backup_state.di_list) {
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
++ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
+ "previous backup not finished");
+ return;
+ }
+@@ -627,7 +688,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
+ if (dev_id < 0)
+ goto err;
+
+- if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_cb, di, task->errp))) {
++ if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_pbs_cb, di, task->errp))) {
+ goto err;
+ }
+
+@@ -648,7 +709,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+ l = g_list_next(l);
+
+- if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_cb, di, task->errp))) {
++ if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_vma_cb, di, task->errp))) {
+ goto err;
+ }
+
+@@ -713,9 +774,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
+ }
+ /* initialize global backup_state now */
+
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
+-
+- backup_state.stat.cancel = false;
++ qemu_mutex_lock(&backup_state.stat.lock);
+
+ if (backup_state.stat.error) {
+ error_free(backup_state.stat.error);
+@@ -738,7 +797,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
+ backup_state.stat.transferred = 0;
+ backup_state.stat.zero_bytes = 0;
+
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
++ qemu_mutex_unlock(&backup_state.stat.lock);
+
+ backup_state.speed = (task->has_speed && task->speed > 0) ? task->speed : 0;
+
+@@ -747,48 +806,6 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
+
+ backup_state.di_list = di_list;
+
+- /* start all jobs (paused state) */
+- l = di_list;
+- while (l) {
+- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+- l = g_list_next(l);
+-
+- // make sure target runs in same aoi_context as source
+- AioContext *aio_context = bdrv_get_aio_context(di->bs);
+- aio_context_acquire(aio_context);
+- GSList *ignore = NULL;
+- bdrv_set_aio_context_ignore(di->target, aio_context, &ignore);
+- g_slist_free(ignore);
+- aio_context_release(aio_context);
+-
+- job = backup_job_create(NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
+- BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
+- JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
+- if (!job || local_err != NULL) {
+- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
+- error_setg(&backup_state.stat.error, "backup_job_create failed");
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+- break;
+- }
+- job_start(&job->job);
+- if (di->target) {
+- bdrv_unref(di->target);
+- di->target = NULL;
+- }
+- }
+-
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+-
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
+- bool no_errors = !backup_state.stat.error;
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+-
+- if (no_errors) {
+- pvebackup_co_run_next_job(); // run one job
+- } else {
+- pvebackup_co_cancel(NULL);
+- }
+-
+ uuid_info = g_malloc0(sizeof(*uuid_info));
+ uuid_info->UUID = uuid_str;
+
+@@ -831,8 +848,6 @@ err:
+ rmdir(backup_dir);
+ }
+
+- qemu_co_mutex_unlock(&backup_state.backup_mutex);
+-
+ task->result = NULL;
+ return;
+ }
+@@ -876,32 +891,31 @@ UuidInfo *qmp_backup(
+ .errp = errp,
+ };
+
+- block_on_coroutine_fn(pvebackup_co_start, &task);
++ qemu_mutex_lock(&backup_state.backup_mutex);
+
+- return task.result;
+-}
++ block_on_coroutine_fn(pvebackup_co_prepare, &task);
+
++ if (*errp == NULL) {
++ create_backup_jobs();
++ qemu_mutex_unlock(&backup_state.backup_mutex);
++ pvebackup_run_next_job();
++ } else {
++ qemu_mutex_unlock(&backup_state.backup_mutex);
++ }
+
+-typedef struct QmpQueryBackupTask {
+- Error **errp;
+- BackupStatus *result;
+-} QmpQueryBackupTask;
++ return task.result;
++}
+
+-static void coroutine_fn pvebackup_co_query(void *opaque)
++BackupStatus *qmp_query_backup(Error **errp)
+ {
+- assert(qemu_in_coroutine());
+-
+- QmpQueryBackupTask *task = opaque;
+-
+ BackupStatus *info = g_malloc0(sizeof(*info));
+
+- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
++ qemu_mutex_lock(&backup_state.stat.lock);
+
+ if (!backup_state.stat.start_time) {
+ /* not started, return {} */
+- task->result = info;
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+- return;
++ qemu_mutex_unlock(&backup_state.stat.lock);
++ return info;
+ }
+
+ info->has_status = true;
+@@ -937,19 +951,7 @@ static void coroutine_fn pvebackup_co_query(void *opaque)
+ info->has_transferred = true;
+ info->transferred = backup_state.stat.transferred;
+
+- task->result = info;
++ qemu_mutex_unlock(&backup_state.stat.lock);
+
+- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
+-}
+-
+-BackupStatus *qmp_query_backup(Error **errp)
+-{
+- QmpQueryBackupTask task = {
+- .errp = errp,
+- .result = NULL,
+- };
+-
+- block_on_coroutine_fn(pvebackup_co_query, &task);
+-
+- return task.result;
++ return info;
+ }
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Dietmar Maurer <dietmar@proxmox.com>
-Date: Mon, 6 Apr 2020 12:17:01 +0200
-Subject: [PATCH] PVE-Backup: pbs-restore - new command to restore from proxmox
- backup server
-
-Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
----
- Makefile | 4 +-
- pbs-restore.c | 217 ++++++++++++++++++++++++++++++++++++++++++++++++++
- 2 files changed, 220 insertions(+), 1 deletion(-)
- create mode 100644 pbs-restore.c
-
-diff --git a/Makefile b/Makefile
-index aec216968d..b73da29f24 100644
---- a/Makefile
-+++ b/Makefile
-@@ -479,7 +479,7 @@ dummy := $(call unnest-vars,, \
-
- include $(SRC_PATH)/tests/Makefile.include
-
--all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) vma$(EXESUF) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
-+all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) vma$(EXESUF) pbs-restore$(EXESUF) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
-
- qemu-version.h: FORCE
- $(call quiet-command, \
-@@ -604,6 +604,8 @@ qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-o
- qemu-storage-daemon$(EXESUF): qemu-storage-daemon.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(chardev-obj-y) $(io-obj-y) $(qom-obj-y) $(storage-daemon-obj-y) $(COMMON_LDADDS)
- qemu-storage-daemon$(EXESUF): LIBS += -lproxmox_backup_qemu
- vma$(EXESUF): vma.o vma-reader.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
-+pbs-restore$(EXESUF): pbs-restore.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
-+pbs-restore$(EXESUF): LIBS += -lproxmox_backup_qemu
-
- qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
-
-diff --git a/pbs-restore.c b/pbs-restore.c
-new file mode 100644
-index 0000000000..4bf37ef1fa
---- /dev/null
-+++ b/pbs-restore.c
-@@ -0,0 +1,217 @@
-+/*
-+ * Qemu image restore helper for Proxmox Backup
-+ *
-+ * Copyright (C) 2019 Proxmox Server Solutions
-+ *
-+ * Authors:
-+ * Dietmar Maurer (dietmar@proxmox.com)
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ *
-+ */
-+
-+#include "qemu/osdep.h"
-+#include <glib.h>
-+#include <getopt.h>
-+#include <string.h>
-+
-+#include "qemu-common.h"
-+#include "qemu/module.h"
-+#include "qemu/error-report.h"
-+#include "qemu/main-loop.h"
-+#include "qemu/cutils.h"
-+#include "qapi/error.h"
-+#include "qapi/qmp/qdict.h"
-+#include "sysemu/block-backend.h"
-+
-+#include <proxmox-backup-qemu.h>
-+
-+static void help(void)
-+{
-+ const char *help_msg =
-+ "usage: pbs-restore [--repository <repo>] snapshot archive-name target [command options]\n"
-+ ;
-+
-+ printf("%s", help_msg);
-+ exit(1);
-+}
-+
-+typedef struct CallbackData {
-+ BlockBackend *target;
-+ uint64_t last_offset;
-+ bool skip_zero;
-+} CallbackData;
-+
-+static int write_callback(
-+ void *callback_data_ptr,
-+ uint64_t offset,
-+ const unsigned char *data,
-+ uint64_t data_len)
-+{
-+ int res = -1;
-+
-+ CallbackData *callback_data = (CallbackData *)callback_data_ptr;
-+
-+ uint64_t last_offset = callback_data->last_offset;
-+ if (offset > last_offset) callback_data->last_offset = offset;
-+
-+ if (data == NULL) {
-+ if (callback_data->skip_zero && offset > last_offset) {
-+ return 0;
-+ }
-+ res = blk_pwrite_zeroes(callback_data->target, offset, data_len, 0);
-+ } else {
-+ res = blk_pwrite(callback_data->target, offset, data, data_len, 0);
-+ }
-+
-+ if (res < 0) {
-+ fprintf(stderr, "blk_pwrite failed at offset %ld length %ld (%d) - %s\n", offset, data_len, res, strerror(-res));
-+ return res;
-+ }
-+
-+ return 0;
-+}
-+
-+int main(int argc, char **argv)
-+{
-+ Error *main_loop_err = NULL;
-+ const char *format = "raw";
-+ const char *repository = NULL;
-+ const char *keyfile = NULL;
-+ int verbose = false;
-+ bool skip_zero = false;
-+
-+ error_init(argv[0]);
-+
-+ for (;;) {
-+ static const struct option long_options[] = {
-+ {"help", no_argument, 0, 'h'},
-+ {"skip-zero", no_argument, 0, 'S'},
-+ {"verbose", no_argument, 0, 'v'},
-+ {"format", required_argument, 0, 'f'},
-+ {"repository", required_argument, 0, 'r'},
-+ {"keyfile", required_argument, 0, 'k'},
-+ {0, 0, 0, 0}
-+ };
-+ int c = getopt_long(argc, argv, "hvf:r:k:", long_options, NULL);
-+ if (c == -1) {
-+ break;
-+ }
-+ switch (c) {
-+ case ':':
-+ fprintf(stderr, "missing argument for option '%s'\n", argv[optind - 1]);
-+ return -1;
-+ case '?':
-+ fprintf(stderr, "unrecognized option '%s'\n", argv[optind - 1]);
-+ return -1;
-+ case 'f':
-+ format = g_strdup(argv[optind - 1]);
-+ break;
-+ case 'r':
-+ repository = g_strdup(argv[optind - 1]);
-+ break;
-+ case 'k':
-+ keyfile = g_strdup(argv[optind - 1]);
-+ break;
-+ case 'v':
-+ verbose = true;
-+ break;
-+ case 'S':
-+ skip_zero = true;
-+ break;
-+ case 'h':
-+ help();
-+ return 0;
-+ }
-+ }
-+
-+ if (optind >= argc - 2) {
-+ fprintf(stderr, "missing arguments\n");
-+ help();
-+ return -1;
-+ }
-+
-+ if (repository == NULL) {
-+ repository = getenv("PBS_REPOSITORY");
-+ }
-+
-+ if (repository == NULL) {
-+ fprintf(stderr, "no repository specified\n");
-+ help();
-+ return -1;
-+ }
-+
-+ char *snapshot = argv[optind++];
-+ char *archive_name = argv[optind++];
-+ char *target = argv[optind++];
-+
-+ const char *password = getenv("PBS_PASSWORD");
-+ const char *fingerprint = getenv("PBS_FINGERPRINT");
-+ const char *key_password = getenv("PBS_ENCRYPTION_PASSWORD");
-+
-+ if (qemu_init_main_loop(&main_loop_err)) {
-+ g_error("%s", error_get_pretty(main_loop_err));
-+ }
-+
-+ bdrv_init();
-+ module_call_init(MODULE_INIT_QOM);
-+
-+ if (verbose) {
-+ fprintf(stderr, "connecting to repository '%s'\n", repository);
-+ }
-+ char *pbs_error = NULL;
-+ ProxmoxRestoreHandle *conn = proxmox_restore_connect(
-+ repository, snapshot, password, keyfile, key_password, fingerprint, &pbs_error);
-+ if (conn == NULL) {
-+ fprintf(stderr, "restore failed: %s\n", pbs_error);
-+ return -1;
-+ }
-+
-+ QDict *options = qdict_new();
-+
-+ if (format) {
-+ qdict_put_str(options, "driver", format);
-+ }
-+
-+
-+ if (verbose) {
-+ fprintf(stderr, "open block backend for target '%s'\n", target);
-+ }
-+ Error *local_err = NULL;
-+ int flags = BDRV_O_RDWR;
-+ BlockBackend *blk = blk_new_open(target, NULL, options, flags, &local_err);
-+ if (!blk) {
-+ fprintf(stderr, "%s\n", error_get_pretty(local_err));
-+ return -1;
-+ }
-+
-+ CallbackData *callback_data = calloc(sizeof(CallbackData), 1);
-+
-+ callback_data->target = blk;
-+ callback_data->skip_zero = skip_zero;
-+ callback_data->last_offset = 0;
-+
-+ // blk_set_enable_write_cache(blk, !writethrough);
-+
-+ if (verbose) {
-+ fprintf(stderr, "starting to restore snapshot '%s'\n", snapshot);
-+ fflush(stderr); // ensure we do not get printed after the progress log
-+ }
-+ int res = proxmox_restore_image(
-+ conn,
-+ archive_name,
-+ write_callback,
-+ callback_data,
-+ &pbs_error,
-+ verbose);
-+
-+ proxmox_restore_disconnect(conn);
-+
-+ if (res < 0) {
-+ fprintf(stderr, "restore failed: %s\n", pbs_error);
-+ return -1;
-+ }
-+
-+ return 0;
-+}
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Dietmar Maurer <dietmar@proxmox.com>
-Date: Mon, 6 Apr 2020 12:17:00 +0200
-Subject: [PATCH] PVE-Backup: avoid coroutines to fix AIO freeze, cleanups
-
-We observed various AIO pool loop freezes, so we decided to avoid
-coroutines and restrict ourselfes using similar code as upstream
-(see blockdev.c: do_backup_common).
-
-* avoid coroutine for job related code (causes hangs with iothreads)
- - We then acquire/release all mutexes outside coroutines now, so we can now
- correctly use a normal mutex.
-
-* split pvebackup_co_dump_cb into:
- - pvebackup_co_dump_pbs_cb and
- - pvebackup_co_dump_pbs_cb
-
-* new helper functions
- - pvebackup_propagate_error
- - pvebackup_error_or_canceled
- - pvebackup_add_transfered_bytes
-
-* avoid cancel flag (not needed)
-
-* simplify backup_cancel logic
-
-There is progress on upstream to support running qmp commands inside
-coroutines, see:
-https://lists.gnu.org/archive/html/qemu-devel/2020-02/msg04852.html
-
-We should consider using that when it is available in upstream qemu.
-
-Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
----
- pve-backup.c | 638 ++++++++++++++++++++++++++-------------------------
- 1 file changed, 320 insertions(+), 318 deletions(-)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index 9ae89fb679..bb917ee972 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -11,11 +11,27 @@
-
- /* PVE backup state and related function */
-
-+/*
-+ * Note: A resume from a qemu_coroutine_yield can happen in a different thread,
-+ * so you may not use normal mutexes within coroutines:
-+ *
-+ * ---bad-example---
-+ * qemu_rec_mutex_lock(lock)
-+ * ...
-+ * qemu_coroutine_yield() // wait for something
-+ * // we are now inside a different thread
-+ * qemu_rec_mutex_unlock(lock) // Crash - wrong thread!!
-+ * ---end-bad-example--
-+ *
-+ * ==> Always use CoMutext inside coroutines.
-+ * ==> Never acquire/release AioContext withing coroutines (because that use QemuRecMutex)
-+ *
-+ */
-
- static struct PVEBackupState {
- struct {
-- // Everithing accessed from qmp command, protected using rwlock
-- CoRwlock rwlock;
-+ // Everithing accessed from qmp_backup_query command is protected using lock
-+ QemuMutex lock;
- Error *error;
- time_t start_time;
- time_t end_time;
-@@ -25,19 +41,20 @@ static struct PVEBackupState {
- size_t total;
- size_t transferred;
- size_t zero_bytes;
-- bool cancel;
- } stat;
- int64_t speed;
- VmaWriter *vmaw;
- ProxmoxBackupHandle *pbs;
- GList *di_list;
-- CoMutex backup_mutex;
-+ QemuMutex backup_mutex;
-+ CoMutex dump_callback_mutex;
- } backup_state;
-
- static void pvebackup_init(void)
- {
-- qemu_co_rwlock_init(&backup_state.stat.rwlock);
-- qemu_co_mutex_init(&backup_state.backup_mutex);
-+ qemu_mutex_init(&backup_state.stat.lock);
-+ qemu_mutex_init(&backup_state.backup_mutex);
-+ qemu_co_mutex_init(&backup_state.dump_callback_mutex);
- }
-
- // initialize PVEBackupState at startup
-@@ -52,10 +69,54 @@ typedef struct PVEBackupDevInfo {
- BlockDriverState *target;
- } PVEBackupDevInfo;
-
--static void pvebackup_co_run_next_job(void);
-+static void pvebackup_run_next_job(void);
-
-+static BlockJob *
-+lookup_active_block_job(PVEBackupDevInfo *di)
-+{
-+ if (!di->completed && di->bs) {
-+ for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
-+ if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
-+ continue;
-+ }
-+
-+ BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
-+ if (bjob && bjob->source_bs == di->bs) {
-+ return job;
-+ }
-+ }
-+ }
-+ return NULL;
-+}
-+
-+static void pvebackup_propagate_error(Error *err)
-+{
-+ qemu_mutex_lock(&backup_state.stat.lock);
-+ error_propagate(&backup_state.stat.error, err);
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-+}
-+
-+static bool pvebackup_error_or_canceled(void)
-+{
-+ qemu_mutex_lock(&backup_state.stat.lock);
-+ bool error_or_canceled = !!backup_state.stat.error;
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-+
-+ return error_or_canceled;
-+}
-+
-+static void pvebackup_add_transfered_bytes(size_t transferred, size_t zero_bytes)
-+{
-+ qemu_mutex_lock(&backup_state.stat.lock);
-+ backup_state.stat.zero_bytes += zero_bytes;
-+ backup_state.stat.transferred += transferred;
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-+}
-+
-+// This may get called from multiple coroutines in multiple io-threads
-+// Note1: this may get called after job_cancel()
- static int coroutine_fn
--pvebackup_co_dump_cb(
-+pvebackup_co_dump_pbs_cb(
- void *opaque,
- uint64_t start,
- uint64_t bytes,
-@@ -67,137 +128,127 @@ pvebackup_co_dump_cb(
- const unsigned char *buf = pbuf;
- PVEBackupDevInfo *di = opaque;
-
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- bool cancel = backup_state.stat.cancel;
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ assert(backup_state.pbs);
-+
-+ Error *local_err = NULL;
-+ int pbs_res = -1;
-+
-+ qemu_co_mutex_lock(&backup_state.dump_callback_mutex);
-
-- if (cancel) {
-- return size; // return success
-+ // avoid deadlock if job is cancelled
-+ if (pvebackup_error_or_canceled()) {
-+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-+ return -1;
- }
-
-- qemu_co_mutex_lock(&backup_state.backup_mutex);
-+ pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
-+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-
-- int ret = -1;
-+ if (pbs_res < 0) {
-+ pvebackup_propagate_error(local_err);
-+ return pbs_res;
-+ } else {
-+ pvebackup_add_transfered_bytes(size, !buf ? size : 0);
-+ }
-
-- if (backup_state.vmaw) {
-- size_t zero_bytes = 0;
-- uint64_t remaining = size;
--
-- uint64_t cluster_num = start / VMA_CLUSTER_SIZE;
-- if ((cluster_num * VMA_CLUSTER_SIZE) != start) {
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- if (!backup_state.stat.error) {
-- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-- error_setg(&backup_state.stat.error,
-- "got unaligned write inside backup dump "
-- "callback (sector %ld)", start);
-- }
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-- return -1; // not aligned to cluster size
-- }
-+ return size;
-+}
-
-- while (remaining > 0) {
-- ret = vma_writer_write(backup_state.vmaw, di->dev_id, cluster_num,
-- buf, &zero_bytes);
-- ++cluster_num;
-- if (buf) {
-- buf += VMA_CLUSTER_SIZE;
-- }
-- if (ret < 0) {
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- if (!backup_state.stat.error) {
-- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-- vma_writer_error_propagate(backup_state.vmaw, &backup_state.stat.error);
-- }
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+// This may get called from multiple coroutines in multiple io-threads
-+static int coroutine_fn
-+pvebackup_co_dump_vma_cb(
-+ void *opaque,
-+ uint64_t start,
-+ uint64_t bytes,
-+ const void *pbuf)
-+{
-+ assert(qemu_in_coroutine());
-
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-- return ret;
-- } else {
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-- backup_state.stat.zero_bytes += zero_bytes;
-- if (remaining >= VMA_CLUSTER_SIZE) {
-- backup_state.stat.transferred += VMA_CLUSTER_SIZE;
-- remaining -= VMA_CLUSTER_SIZE;
-- } else {
-- backup_state.stat.transferred += remaining;
-- remaining = 0;
-- }
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-- }
-- }
-- } else if (backup_state.pbs) {
-- Error *local_err = NULL;
-- int pbs_res = -1;
-+ const uint64_t size = bytes;
-+ const unsigned char *buf = pbuf;
-+ PVEBackupDevInfo *di = opaque;
-
-- pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
-+ int ret = -1;
-
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ assert(backup_state.vmaw);
-
-- if (pbs_res < 0) {
-- error_propagate(&backup_state.stat.error, local_err);
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-- return pbs_res;
-- } else {
-- if (!buf) {
-- backup_state.stat.zero_bytes += size;
-- }
-- backup_state.stat.transferred += size;
-+ uint64_t remaining = size;
-+
-+ uint64_t cluster_num = start / VMA_CLUSTER_SIZE;
-+ if ((cluster_num * VMA_CLUSTER_SIZE) != start) {
-+ Error *local_err = NULL;
-+ error_setg(&local_err,
-+ "got unaligned write inside backup dump "
-+ "callback (sector %ld)", start);
-+ pvebackup_propagate_error(local_err);
-+ return -1; // not aligned to cluster size
-+ }
-+
-+ while (remaining > 0) {
-+ qemu_co_mutex_lock(&backup_state.dump_callback_mutex);
-+ // avoid deadlock if job is cancelled
-+ if (pvebackup_error_or_canceled()) {
-+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-+ return -1;
- }
-
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ size_t zero_bytes = 0;
-+ ret = vma_writer_write(backup_state.vmaw, di->dev_id, cluster_num, buf, &zero_bytes);
-+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-
-- } else {
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-- if (!buf) {
-- backup_state.stat.zero_bytes += size;
-+ ++cluster_num;
-+ if (buf) {
-+ buf += VMA_CLUSTER_SIZE;
-+ }
-+ if (ret < 0) {
-+ Error *local_err = NULL;
-+ vma_writer_error_propagate(backup_state.vmaw, &local_err);
-+ pvebackup_propagate_error(local_err);
-+ return ret;
-+ } else {
-+ if (remaining >= VMA_CLUSTER_SIZE) {
-+ assert(ret == VMA_CLUSTER_SIZE);
-+ pvebackup_add_transfered_bytes(VMA_CLUSTER_SIZE, zero_bytes);
-+ remaining -= VMA_CLUSTER_SIZE;
-+ } else {
-+ assert(ret == remaining);
-+ pvebackup_add_transfered_bytes(remaining, zero_bytes);
-+ remaining = 0;
-+ }
- }
-- backup_state.stat.transferred += size;
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
- }
-
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
--
- return size;
- }
-
--static void coroutine_fn pvebackup_co_cleanup(void)
-+// assumes the caller holds backup_mutex
-+static void coroutine_fn pvebackup_co_cleanup(void *unused)
- {
- assert(qemu_in_coroutine());
-
-- qemu_co_mutex_lock(&backup_state.backup_mutex);
--
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-+ qemu_mutex_lock(&backup_state.stat.lock);
- backup_state.stat.end_time = time(NULL);
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-
- if (backup_state.vmaw) {
- Error *local_err = NULL;
- vma_writer_close(backup_state.vmaw, &local_err);
-
- if (local_err != NULL) {
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-- error_propagate(&backup_state.stat.error, local_err);
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-- }
-+ pvebackup_propagate_error(local_err);
-+ }
-
- backup_state.vmaw = NULL;
- }
-
- if (backup_state.pbs) {
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
-- if (!error_or_canceled) {
-+ if (!pvebackup_error_or_canceled()) {
- Error *local_err = NULL;
- proxmox_backup_co_finish(backup_state.pbs, &local_err);
- if (local_err != NULL) {
-- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-- error_propagate(&backup_state.stat.error, local_err);
-- }
-+ pvebackup_propagate_error(local_err);
-+ }
- }
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-
- proxmox_backup_disconnect(backup_state.pbs);
- backup_state.pbs = NULL;
-@@ -205,43 +256,14 @@ static void coroutine_fn pvebackup_co_cleanup(void)
-
- g_list_free(backup_state.di_list);
- backup_state.di_list = NULL;
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
- }
-
--typedef struct PVEBackupCompeteCallbackData {
-- PVEBackupDevInfo *di;
-- int result;
--} PVEBackupCompeteCallbackData;
--
--static void coroutine_fn pvebackup_co_complete_cb(void *opaque)
-+// assumes the caller holds backup_mutex
-+static void coroutine_fn pvebackup_complete_stream(void *opaque)
- {
-- assert(qemu_in_coroutine());
--
-- PVEBackupCompeteCallbackData *cb_data = opaque;
--
-- qemu_co_mutex_lock(&backup_state.backup_mutex);
--
-- PVEBackupDevInfo *di = cb_data->di;
-- int ret = cb_data->result;
--
-- di->completed = true;
--
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
--
-- if (ret < 0 && !backup_state.stat.error) {
-- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-- error_setg(&backup_state.stat.error, "job failed with err %d - %s",
-- ret, strerror(-ret));
-- }
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
--
-- di->bs = NULL;
-+ PVEBackupDevInfo *di = opaque;
-
-- if (di->target) {
-- bdrv_unref(di->target);
-- di->target = NULL;
-- }
-+ bool error_or_canceled = pvebackup_error_or_canceled();
-
- if (backup_state.vmaw) {
- vma_writer_close_stream(backup_state.vmaw, di->dev_id);
-@@ -251,110 +273,101 @@ static void coroutine_fn pvebackup_co_complete_cb(void *opaque)
- Error *local_err = NULL;
- proxmox_backup_co_close_image(backup_state.pbs, di->dev_id, &local_err);
- if (local_err != NULL) {
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-- error_propagate(&backup_state.stat.error, local_err);
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ pvebackup_propagate_error(local_err);
- }
- }
-+}
-
-- // remove self from job queue
-- backup_state.di_list = g_list_remove(backup_state.di_list, di);
-- g_free(di);
-+static void pvebackup_complete_cb(void *opaque, int ret)
-+{
-+ assert(!qemu_in_coroutine());
-
-- int pending_jobs = g_list_length(backup_state.di_list);
-+ PVEBackupDevInfo *di = opaque;
-
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ qemu_mutex_lock(&backup_state.backup_mutex);
-
-- if (pending_jobs > 0) {
-- pvebackup_co_run_next_job();
-- } else {
-- pvebackup_co_cleanup();
-+ di->completed = true;
-+
-+ if (ret < 0) {
-+ Error *local_err = NULL;
-+ error_setg(&local_err, "job failed with err %d - %s", ret, strerror(-ret));
-+ pvebackup_propagate_error(local_err);
- }
--}
-
--static void pvebackup_complete_cb(void *opaque, int ret)
--{
-- // This can be called from the main loop, or from a coroutine
-- PVEBackupCompeteCallbackData cb_data = {
-- .di = opaque,
-- .result = ret,
-- };
-+ di->bs = NULL;
-
-- if (qemu_in_coroutine()) {
-- pvebackup_co_complete_cb(&cb_data);
-- } else {
-- block_on_coroutine_fn(pvebackup_co_complete_cb, &cb_data);
-- }
--}
-+ assert(di->target == NULL);
-
--static void coroutine_fn pvebackup_co_cancel(void *opaque)
--{
-- assert(qemu_in_coroutine());
-+ block_on_coroutine_fn(pvebackup_complete_stream, di);
-
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-- backup_state.stat.cancel = true;
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ // remove self from job queue
-+ backup_state.di_list = g_list_remove(backup_state.di_list, di);
-
-- qemu_co_mutex_lock(&backup_state.backup_mutex);
-+ g_free(di);
-
-- // Avoid race between block jobs and backup-cancel command:
-- if (!(backup_state.vmaw || backup_state.pbs)) {
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-- return;
-- }
-+ qemu_mutex_unlock(&backup_state.backup_mutex);
-
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- if (!backup_state.stat.error) {
-- qemu_co_rwlock_upgrade(&backup_state.stat.rwlock);
-- error_setg(&backup_state.stat.error, "backup cancelled");
-- }
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ pvebackup_run_next_job();
-+}
-+
-+static void pvebackup_cancel(void)
-+{
-+ assert(!qemu_in_coroutine());
-+
-+ Error *cancel_err = NULL;
-+ error_setg(&cancel_err, "backup canceled");
-+ pvebackup_propagate_error(cancel_err);
-+
-+ qemu_mutex_lock(&backup_state.backup_mutex);
-
- if (backup_state.vmaw) {
- /* make sure vma writer does not block anymore */
-- vma_writer_set_error(backup_state.vmaw, "backup cancelled");
-+ vma_writer_set_error(backup_state.vmaw, "backup canceled");
- }
-
- if (backup_state.pbs) {
-- proxmox_backup_abort(backup_state.pbs, "backup cancelled");
-+ proxmox_backup_abort(backup_state.pbs, "backup canceled");
- }
-
-- bool running_jobs = 0;
-- GList *l = backup_state.di_list;
-- while (l) {
-- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-- l = g_list_next(l);
-- if (!di->completed && di->bs) {
-- for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
-- if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
-- continue;
-- }
-+ qemu_mutex_unlock(&backup_state.backup_mutex);
-
-- BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
-- if (bjob && bjob->source_bs == di->bs) {
-- AioContext *aio_context = job->job.aio_context;
-- aio_context_acquire(aio_context);
-+ for(;;) {
-
-- if (!di->completed) {
-- running_jobs += 1;
-- job_cancel(&job->job, false);
-- }
-- aio_context_release(aio_context);
-- }
-+ BlockJob *next_job = NULL;
-+
-+ qemu_mutex_lock(&backup_state.backup_mutex);
-+
-+ GList *l = backup_state.di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ BlockJob *job = lookup_active_block_job(di);
-+ if (job != NULL) {
-+ next_job = job;
-+ break;
- }
- }
-- }
-
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+ qemu_mutex_unlock(&backup_state.backup_mutex);
-
-- if (running_jobs == 0) pvebackup_co_cleanup(); // else job will call completion handler
-+ if (next_job) {
-+ AioContext *aio_context = next_job->job.aio_context;
-+ aio_context_acquire(aio_context);
-+ job_cancel_sync(&next_job->job);
-+ aio_context_release(aio_context);
-+ } else {
-+ break;
-+ }
-+ }
- }
-
- void qmp_backup_cancel(Error **errp)
- {
-- block_on_coroutine_fn(pvebackup_co_cancel, NULL);
-+ pvebackup_cancel();
- }
-
-+// assumes the caller holds backup_mutex
- static int coroutine_fn pvebackup_co_add_config(
- const char *file,
- const char *name,
-@@ -406,46 +419,97 @@ static int coroutine_fn pvebackup_co_add_config(
-
- bool job_should_pause(Job *job);
-
--static void coroutine_fn pvebackup_co_run_next_job(void)
-+static void pvebackup_run_next_job(void)
- {
-- assert(qemu_in_coroutine());
-+ assert(!qemu_in_coroutine());
-
-- qemu_co_mutex_lock(&backup_state.backup_mutex);
-+ qemu_mutex_lock(&backup_state.backup_mutex);
-
- GList *l = backup_state.di_list;
- while (l) {
- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
- l = g_list_next(l);
-- if (!di->completed && di->bs) {
-- for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
-- if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
-- continue;
-- }
-
-- BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
-- if (bjob && bjob->source_bs == di->bs) {
-- AioContext *aio_context = job->job.aio_context;
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-- aio_context_acquire(aio_context);
--
-- if (job_should_pause(&job->job)) {
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- bool error_or_canceled = backup_state.stat.error || backup_state.stat.cancel;
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
--
-- if (error_or_canceled) {
-- job_cancel(&job->job, false);
-- } else {
-- job_resume(&job->job);
-- }
-- }
-- aio_context_release(aio_context);
-- return;
-+ BlockJob *job = lookup_active_block_job(di);
-+
-+ if (job) {
-+ qemu_mutex_unlock(&backup_state.backup_mutex);
-+
-+ AioContext *aio_context = job->job.aio_context;
-+ aio_context_acquire(aio_context);
-+
-+ if (job_should_pause(&job->job)) {
-+ bool error_or_canceled = pvebackup_error_or_canceled();
-+ if (error_or_canceled) {
-+ job_cancel_sync(&job->job);
-+ } else {
-+ job_resume(&job->job);
- }
- }
-+ aio_context_release(aio_context);
-+ return;
-+ }
-+ }
-+
-+ block_on_coroutine_fn(pvebackup_co_cleanup, NULL); // no more jobs, run cleanup
-+
-+ qemu_mutex_unlock(&backup_state.backup_mutex);
-+}
-+
-+static bool create_backup_jobs(void) {
-+
-+ assert(!qemu_in_coroutine());
-+
-+ Error *local_err = NULL;
-+
-+ /* create and start all jobs (paused state) */
-+ GList *l = backup_state.di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ assert(di->target != NULL);
-+
-+ AioContext *aio_context = bdrv_get_aio_context(di->bs);
-+ aio_context_acquire(aio_context);
-+
-+ BlockJob *job = backup_job_create(
-+ NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
-+ BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
-+ JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
-+
-+ aio_context_release(aio_context);
-+
-+ if (!job || local_err != NULL) {
-+ Error *create_job_err = NULL;
-+ error_setg(&create_job_err, "backup_job_create failed: %s",
-+ local_err ? error_get_pretty(local_err) : "null");
-+
-+ pvebackup_propagate_error(create_job_err);
-+ break;
-+ }
-+ job_start(&job->job);
-+
-+ bdrv_unref(di->target);
-+ di->target = NULL;
-+ }
-+
-+ bool errors = pvebackup_error_or_canceled();
-+
-+ if (errors) {
-+ l = backup_state.di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ if (di->target) {
-+ bdrv_unref(di->target);
-+ di->target = NULL;
-+ }
- }
- }
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-+
-+ return errors;
- }
-
- typedef struct QmpBackupTask {
-@@ -476,7 +540,8 @@ typedef struct QmpBackupTask {
- UuidInfo *result;
- } QmpBackupTask;
-
--static void coroutine_fn pvebackup_co_start(void *opaque)
-+// assumes the caller holds backup_mutex
-+static void coroutine_fn pvebackup_co_prepare(void *opaque)
- {
- assert(qemu_in_coroutine());
-
-@@ -495,16 +560,12 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
- GList *di_list = NULL;
- GList *l;
- UuidInfo *uuid_info;
-- BlockJob *job;
-
- const char *config_name = "qemu-server.conf";
- const char *firewall_name = "qemu-server.fw";
-
-- qemu_co_mutex_lock(&backup_state.backup_mutex);
--
- if (backup_state.di_list) {
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
-- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
-+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
- "previous backup not finished");
- return;
- }
-@@ -631,7 +692,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
- if (dev_id < 0)
- goto err;
-
-- if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_cb, di, task->errp))) {
-+ if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_pbs_cb, di, task->errp))) {
- goto err;
- }
-
-@@ -652,7 +713,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
- l = g_list_next(l);
-
-- if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_cb, di, task->errp))) {
-+ if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_vma_cb, di, task->errp))) {
- goto err;
- }
-
-@@ -717,9 +778,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
- }
- /* initialize global backup_state now */
-
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
--
-- backup_state.stat.cancel = false;
-+ qemu_mutex_lock(&backup_state.stat.lock);
-
- if (backup_state.stat.error) {
- error_free(backup_state.stat.error);
-@@ -742,7 +801,7 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
- backup_state.stat.transferred = 0;
- backup_state.stat.zero_bytes = 0;
-
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-
- backup_state.speed = (task->has_speed && task->speed > 0) ? task->speed : 0;
-
-@@ -751,48 +810,6 @@ static void coroutine_fn pvebackup_co_start(void *opaque)
-
- backup_state.di_list = di_list;
-
-- /* start all jobs (paused state) */
-- l = di_list;
-- while (l) {
-- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-- l = g_list_next(l);
--
-- // make sure target runs in same aoi_context as source
-- AioContext *aio_context = bdrv_get_aio_context(di->bs);
-- aio_context_acquire(aio_context);
-- GSList *ignore = NULL;
-- bdrv_set_aio_context_ignore(di->target, aio_context, &ignore);
-- g_slist_free(ignore);
-- aio_context_release(aio_context);
--
-- job = backup_job_create(NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
-- BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
-- JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
-- if (!job || local_err != NULL) {
-- qemu_co_rwlock_wrlock(&backup_state.stat.rwlock);
-- error_setg(&backup_state.stat.error, "backup_job_create failed");
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-- break;
-- }
-- job_start(&job->job);
-- if (di->target) {
-- bdrv_unref(di->target);
-- di->target = NULL;
-- }
-- }
--
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
--
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-- bool no_errors = !backup_state.stat.error;
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
--
-- if (no_errors) {
-- pvebackup_co_run_next_job(); // run one job
-- } else {
-- pvebackup_co_cancel(NULL);
-- }
--
- uuid_info = g_malloc0(sizeof(*uuid_info));
- uuid_info->UUID = uuid_str;
-
-@@ -835,8 +852,6 @@ err:
- rmdir(backup_dir);
- }
-
-- qemu_co_mutex_unlock(&backup_state.backup_mutex);
--
- task->result = NULL;
- return;
- }
-@@ -880,32 +895,31 @@ UuidInfo *qmp_backup(
- .errp = errp,
- };
-
-- block_on_coroutine_fn(pvebackup_co_start, &task);
-+ qemu_mutex_lock(&backup_state.backup_mutex);
-
-- return task.result;
--}
-+ block_on_coroutine_fn(pvebackup_co_prepare, &task);
-
-+ if (*errp == NULL) {
-+ create_backup_jobs();
-+ qemu_mutex_unlock(&backup_state.backup_mutex);
-+ pvebackup_run_next_job();
-+ } else {
-+ qemu_mutex_unlock(&backup_state.backup_mutex);
-+ }
-
--typedef struct QmpQueryBackupTask {
-- Error **errp;
-- BackupStatus *result;
--} QmpQueryBackupTask;
-+ return task.result;
-+}
-
--static void coroutine_fn pvebackup_co_query(void *opaque)
-+BackupStatus *qmp_query_backup(Error **errp)
- {
-- assert(qemu_in_coroutine());
--
-- QmpQueryBackupTask *task = opaque;
--
- BackupStatus *info = g_malloc0(sizeof(*info));
-
-- qemu_co_rwlock_rdlock(&backup_state.stat.rwlock);
-+ qemu_mutex_lock(&backup_state.stat.lock);
-
- if (!backup_state.stat.start_time) {
- /* not started, return {} */
-- task->result = info;
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
-- return;
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-+ return info;
- }
-
- info->has_status = true;
-@@ -941,19 +955,7 @@ static void coroutine_fn pvebackup_co_query(void *opaque)
- info->has_transferred = true;
- info->transferred = backup_state.stat.transferred;
-
-- task->result = info;
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-
-- qemu_co_rwlock_unlock(&backup_state.stat.rwlock);
--}
--
--BackupStatus *qmp_query_backup(Error **errp)
--{
-- QmpQueryBackupTask task = {
-- .errp = errp,
-- .result = NULL,
-- };
--
-- block_on_coroutine_fn(pvebackup_co_query, &task);
--
-- return task.result;
-+ return info;
- }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: John Snow <jsnow@redhat.com>
+Date: Mon, 6 Apr 2020 12:17:03 +0200
+Subject: [PATCH] drive-mirror: add support for sync=bitmap mode=never
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+This patch adds support for the "BITMAP" sync mode to drive-mirror and
+blockdev-mirror. It adds support only for the BitmapSyncMode "never,"
+because it's the simplest mode.
+
+This mode simply uses a user-provided bitmap as an initial copy
+manifest, and then does not clear any bits in the bitmap at the
+conclusion of the operation.
+
+Any new writes dirtied during the operation are copied out, in contrast
+to backup. Note that whether these writes are reflected in the bitmap
+at the conclusion of the operation depends on whether that bitmap is
+actually recording!
+
+This patch was originally based on one by Ma Haocong, but it has since
+been modified pretty heavily.
+
+Suggested-by: Ma Haocong <mahaocong@didichuxing.com>
+Signed-off-by: Ma Haocong <mahaocong@didichuxing.com>
+Signed-off-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
+---
+ block/mirror.c | 98 ++++++++++++++++++++++++++++++-------
+ blockdev.c | 39 +++++++++++++--
+ include/block/block_int.h | 4 +-
+ qapi/block-core.json | 29 +++++++++--
+ tests/test-block-iothread.c | 4 +-
+ 5 files changed, 145 insertions(+), 29 deletions(-)
+
+diff --git a/block/mirror.c b/block/mirror.c
+index e8e8844afc..100e828639 100644
+--- a/block/mirror.c
++++ b/block/mirror.c
+@@ -49,7 +49,7 @@ typedef struct MirrorBlockJob {
+ BlockDriverState *to_replace;
+ /* Used to block operations on the drive-mirror-replace target */
+ Error *replace_blocker;
+- bool is_none_mode;
++ MirrorSyncMode sync_mode;
+ BlockMirrorBackingMode backing_mode;
+ /* Whether the target image requires explicit zero-initialization */
+ bool zero_target;
+@@ -64,6 +64,8 @@ typedef struct MirrorBlockJob {
+ size_t buf_size;
+ int64_t bdev_length;
+ unsigned long *cow_bitmap;
++ BdrvDirtyBitmap *sync_bitmap;
++ BitmapSyncMode bitmap_mode;
+ BdrvDirtyBitmap *dirty_bitmap;
+ BdrvDirtyBitmapIter *dbi;
+ uint8_t *buf;
+@@ -676,7 +678,8 @@ static int mirror_exit_common(Job *job)
+ bdrv_child_refresh_perms(mirror_top_bs, mirror_top_bs->backing,
+ &error_abort);
+ if (!abort && s->backing_mode == MIRROR_SOURCE_BACKING_CHAIN) {
+- BlockDriverState *backing = s->is_none_mode ? src : s->base;
++ BlockDriverState *backing;
++ backing = s->sync_mode == MIRROR_SYNC_MODE_NONE ? src : s->base;
+ if (backing_bs(target_bs) != backing) {
+ bdrv_set_backing_hd(target_bs, backing, &local_err);
+ if (local_err) {
+@@ -771,6 +774,16 @@ static void mirror_abort(Job *job)
+ assert(ret == 0);
+ }
+
++/* Always called after commit/abort. */
++static void mirror_clean(Job *job)
++{
++ MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
++
++ if (s->sync_bitmap) {
++ bdrv_dirty_bitmap_set_busy(s->sync_bitmap, false);
++ }
++}
++
+ static void coroutine_fn mirror_throttle(MirrorBlockJob *s)
+ {
+ int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
+@@ -952,7 +965,8 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
+ mirror_free_init(s);
+
+ s->last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
+- if (!s->is_none_mode) {
++ if ((s->sync_mode == MIRROR_SYNC_MODE_TOP) ||
++ (s->sync_mode == MIRROR_SYNC_MODE_FULL)) {
+ ret = mirror_dirty_init(s);
+ if (ret < 0 || job_is_cancelled(&s->common.job)) {
+ goto immediate_exit;
+@@ -1184,6 +1198,7 @@ static const BlockJobDriver mirror_job_driver = {
+ .run = mirror_run,
+ .prepare = mirror_prepare,
+ .abort = mirror_abort,
++ .clean = mirror_clean,
+ .pause = mirror_pause,
+ .complete = mirror_complete,
+ },
+@@ -1199,6 +1214,7 @@ static const BlockJobDriver commit_active_job_driver = {
+ .run = mirror_run,
+ .prepare = mirror_prepare,
+ .abort = mirror_abort,
++ .clean = mirror_clean,
+ .pause = mirror_pause,
+ .complete = mirror_complete,
+ },
+@@ -1547,7 +1563,10 @@ static BlockJob *mirror_start_job(
+ BlockCompletionFunc *cb,
+ void *opaque,
+ const BlockJobDriver *driver,
+- bool is_none_mode, BlockDriverState *base,
++ MirrorSyncMode sync_mode,
++ BdrvDirtyBitmap *bitmap,
++ BitmapSyncMode bitmap_mode,
++ BlockDriverState *base,
+ bool auto_complete, const char *filter_node_name,
+ bool is_mirror, MirrorCopyMode copy_mode,
+ Error **errp)
+@@ -1560,10 +1579,39 @@ static BlockJob *mirror_start_job(
+ Error *local_err = NULL;
+ int ret;
+
+- if (granularity == 0) {
+- granularity = bdrv_get_default_bitmap_granularity(target);
++ if (sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
++ error_setg(errp, "Sync mode '%s' not supported",
++ MirrorSyncMode_str(sync_mode));
++ return NULL;
++ } else if (sync_mode == MIRROR_SYNC_MODE_BITMAP) {
++ if (!bitmap) {
++ error_setg(errp, "Must provide a valid bitmap name for '%s'"
++ " sync mode",
++ MirrorSyncMode_str(sync_mode));
++ return NULL;
++ } else if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
++ error_setg(errp,
++ "Bitmap Sync Mode '%s' is not supported by Mirror",
++ BitmapSyncMode_str(bitmap_mode));
++ }
++ } else if (bitmap) {
++ error_setg(errp,
++ "sync mode '%s' is not compatible with bitmaps",
++ MirrorSyncMode_str(sync_mode));
++ return NULL;
+ }
+
++ if (bitmap) {
++ if (granularity) {
++ error_setg(errp, "granularity (%d)"
++ "cannot be specified when a bitmap is provided",
++ granularity);
++ return NULL;
++ }
++ granularity = bdrv_dirty_bitmap_granularity(bitmap);
++ } else if (granularity == 0) {
++ granularity = bdrv_get_default_bitmap_granularity(target);
++ }
+ assert(is_power_of_2(granularity));
+
+ if (buf_size < 0) {
+@@ -1667,7 +1715,9 @@ static BlockJob *mirror_start_job(
+ s->replaces = g_strdup(replaces);
+ s->on_source_error = on_source_error;
+ s->on_target_error = on_target_error;
+- s->is_none_mode = is_none_mode;
++ s->sync_mode = sync_mode;
++ s->sync_bitmap = bitmap;
++ s->bitmap_mode = bitmap_mode;
+ s->backing_mode = backing_mode;
+ s->zero_target = zero_target;
+ s->copy_mode = copy_mode;
+@@ -1687,6 +1737,18 @@ static BlockJob *mirror_start_job(
+ bdrv_disable_dirty_bitmap(s->dirty_bitmap);
+ }
+
++ if (s->sync_bitmap) {
++ bdrv_dirty_bitmap_set_busy(s->sync_bitmap, true);
++ }
++
++ if (s->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
++ bdrv_merge_dirty_bitmap(s->dirty_bitmap, s->sync_bitmap,
++ NULL, &local_err);
++ if (local_err) {
++ goto fail;
++ }
++ }
++
+ ret = block_job_add_bdrv(&s->common, "source", bs, 0,
+ BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE |
+ BLK_PERM_CONSISTENT_READ,
+@@ -1740,6 +1802,9 @@ fail:
+ if (s->dirty_bitmap) {
+ bdrv_release_dirty_bitmap(s->dirty_bitmap);
+ }
++ if (s->sync_bitmap) {
++ bdrv_dirty_bitmap_set_busy(s->sync_bitmap, false);
++ }
+ job_early_fail(&s->common.job);
+ }
+
+@@ -1757,29 +1822,23 @@ void mirror_start(const char *job_id, BlockDriverState *bs,
+ BlockDriverState *target, const char *replaces,
+ int creation_flags, int64_t speed,
+ uint32_t granularity, int64_t buf_size,
+- MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
++ MirrorSyncMode mode, BdrvDirtyBitmap *bitmap,
++ BitmapSyncMode bitmap_mode,
++ BlockMirrorBackingMode backing_mode,
+ bool zero_target,
+ BlockdevOnError on_source_error,
+ BlockdevOnError on_target_error,
+ bool unmap, const char *filter_node_name,
+ MirrorCopyMode copy_mode, Error **errp)
+ {
+- bool is_none_mode;
+ BlockDriverState *base;
+
+- if ((mode == MIRROR_SYNC_MODE_INCREMENTAL) ||
+- (mode == MIRROR_SYNC_MODE_BITMAP)) {
+- error_setg(errp, "Sync mode '%s' not supported",
+- MirrorSyncMode_str(mode));
+- return;
+- }
+- is_none_mode = mode == MIRROR_SYNC_MODE_NONE;
+ base = mode == MIRROR_SYNC_MODE_TOP ? backing_bs(bs) : NULL;
+ mirror_start_job(job_id, bs, creation_flags, target, replaces,
+ speed, granularity, buf_size, backing_mode, zero_target,
+ on_source_error, on_target_error, unmap, NULL, NULL,
+- &mirror_job_driver, is_none_mode, base, false,
+- filter_node_name, true, copy_mode, errp);
++ &mirror_job_driver, mode, bitmap, bitmap_mode, base,
++ false, filter_node_name, true, copy_mode, errp);
+ }
+
+ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
+@@ -1805,7 +1864,8 @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
+ job_id, bs, creation_flags, base, NULL, speed, 0, 0,
+ MIRROR_LEAVE_BACKING_CHAIN, false,
+ on_error, on_error, true, cb, opaque,
+- &commit_active_job_driver, false, base, auto_complete,
++ &commit_active_job_driver, MIRROR_SYNC_MODE_FULL,
++ NULL, 0, base, auto_complete,
+ filter_node_name, false, MIRROR_COPY_MODE_BACKGROUND,
+ &local_err);
+ if (local_err) {
+diff --git a/blockdev.c b/blockdev.c
+index 681da7c8b6..02d58e7645 100644
+--- a/blockdev.c
++++ b/blockdev.c
+@@ -2876,6 +2876,10 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
+ BlockDriverState *target,
+ bool has_replaces, const char *replaces,
+ enum MirrorSyncMode sync,
++ bool has_bitmap,
++ const char *bitmap_name,
++ bool has_bitmap_mode,
++ BitmapSyncMode bitmap_mode,
+ BlockMirrorBackingMode backing_mode,
+ bool zero_target,
+ bool has_speed, int64_t speed,
+@@ -2894,6 +2898,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
+ Error **errp)
+ {
+ int job_flags = JOB_DEFAULT;
++ BdrvDirtyBitmap *bitmap = NULL;
+
+ if (!has_speed) {
+ speed = 0;
+@@ -2948,6 +2953,29 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
+ sync = MIRROR_SYNC_MODE_FULL;
+ }
+
++ if (has_bitmap) {
++ if (granularity) {
++ error_setg(errp, "Granularity and bitmap cannot both be set");
++ return;
++ }
++
++ if (!has_bitmap_mode) {
++ error_setg(errp, "bitmap-mode must be specified if"
++ " a bitmap is provided");
++ return;
++ }
++
++ bitmap = bdrv_find_dirty_bitmap(bs, bitmap_name);
++ if (!bitmap) {
++ error_setg(errp, "Dirty bitmap '%s' not found", bitmap_name);
++ return;
++ }
++
++ if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
++ return;
++ }
++ }
++
+ if (has_replaces) {
+ BlockDriverState *to_replace_bs;
+ AioContext *replace_aio_context;
+@@ -2985,8 +3013,8 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
+ * and will allow to check whether the node still exist at mirror completion
+ */
+ mirror_start(job_id, bs, target,
+- has_replaces ? replaces : NULL, job_flags,
+- speed, granularity, buf_size, sync, backing_mode, zero_target,
++ has_replaces ? replaces : NULL, job_flags, speed, granularity,
++ buf_size, sync, bitmap, bitmap_mode, backing_mode, zero_target,
+ on_source_error, on_target_error, unmap, filter_node_name,
+ copy_mode, errp);
+ }
+@@ -3127,6 +3155,8 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
+
+ blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,
+ arg->has_replaces, arg->replaces, arg->sync,
++ arg->has_bitmap, arg->bitmap,
++ arg->has_bitmap_mode, arg->bitmap_mode,
+ backing_mode, zero_target,
+ arg->has_speed, arg->speed,
+ arg->has_granularity, arg->granularity,
+@@ -3148,6 +3178,8 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
+ const char *device, const char *target,
+ bool has_replaces, const char *replaces,
+ MirrorSyncMode sync,
++ bool has_bitmap, const char *bitmap,
++ bool has_bitmap_mode, BitmapSyncMode bitmap_mode,
+ bool has_speed, int64_t speed,
+ bool has_granularity, uint32_t granularity,
+ bool has_buf_size, int64_t buf_size,
+@@ -3197,7 +3229,8 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
+ }
+
+ blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,
+- has_replaces, replaces, sync, backing_mode,
++ has_replaces, replaces, sync, has_bitmap,
++ bitmap, has_bitmap_mode, bitmap_mode, backing_mode,
+ zero_target, has_speed, speed,
+ has_granularity, granularity,
+ has_buf_size, buf_size,
+diff --git a/include/block/block_int.h b/include/block/block_int.h
+index 8dda6f769d..279bd4ab61 100644
+--- a/include/block/block_int.h
++++ b/include/block/block_int.h
+@@ -1245,7 +1245,9 @@ void mirror_start(const char *job_id, BlockDriverState *bs,
+ BlockDriverState *target, const char *replaces,
+ int creation_flags, int64_t speed,
+ uint32_t granularity, int64_t buf_size,
+- MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
++ MirrorSyncMode mode, BdrvDirtyBitmap *bitmap,
++ BitmapSyncMode bitmap_mode,
++ BlockMirrorBackingMode backing_mode,
+ bool zero_target,
+ BlockdevOnError on_source_error,
+ BlockdevOnError on_target_error,
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index 69db270b1a..9db8e26517 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -2064,10 +2064,19 @@
+ # (all the disk, only the sectors allocated in the topmost image, or
+ # only new I/O).
+ #
++# @bitmap: The name of a bitmap to use for sync=bitmap mode. This argument must
++# be present for bitmap mode and absent otherwise. The bitmap's
++# granularity is used instead of @granularity (since 4.1).
++#
++# @bitmap-mode: Specifies the type of data the bitmap should contain after
++# the operation concludes. Must be present if sync is "bitmap".
++# Must NOT be present otherwise. (Since 4.1)
++#
+ # @granularity: granularity of the dirty bitmap, default is 64K
+ # if the image format doesn't have clusters, 4K if the clusters
+ # are smaller than that, else the cluster size. Must be a
+-# power of 2 between 512 and 64M (since 1.4).
++# power of 2 between 512 and 64M. Must not be specified if
++# @bitmap is present (since 1.4).
+ #
+ # @buf-size: maximum amount of data in flight from source to
+ # target (since 1.4).
+@@ -2105,7 +2114,9 @@
+ { 'struct': 'DriveMirror',
+ 'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
+ '*format': 'str', '*node-name': 'str', '*replaces': 'str',
+- 'sync': 'MirrorSyncMode', '*mode': 'NewImageMode',
++ 'sync': 'MirrorSyncMode', '*bitmap': 'str',
++ '*bitmap-mode': 'BitmapSyncMode',
++ '*mode': 'NewImageMode',
+ '*speed': 'int', '*granularity': 'uint32',
+ '*buf-size': 'int', '*on-source-error': 'BlockdevOnError',
+ '*on-target-error': 'BlockdevOnError',
+@@ -2372,10 +2383,19 @@
+ # (all the disk, only the sectors allocated in the topmost image, or
+ # only new I/O).
+ #
++# @bitmap: The name of a bitmap to use for sync=bitmap mode. This argument must
++# be present for bitmap mode and absent otherwise. The bitmap's
++# granularity is used instead of @granularity (since 4.1).
++#
++# @bitmap-mode: Specifies the type of data the bitmap should contain after
++# the operation concludes. Must be present if sync is "bitmap".
++# Must NOT be present otherwise. (Since 4.1)
++#
+ # @granularity: granularity of the dirty bitmap, default is 64K
+ # if the image format doesn't have clusters, 4K if the clusters
+ # are smaller than that, else the cluster size. Must be a
+-# power of 2 between 512 and 64M
++# power of 2 between 512 and 64M . Must not be specified if
++# @bitmap is present.
+ #
+ # @buf-size: maximum amount of data in flight from source to
+ # target
+@@ -2424,7 +2444,8 @@
+ { 'command': 'blockdev-mirror',
+ 'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
+ '*replaces': 'str',
+- 'sync': 'MirrorSyncMode',
++ 'sync': 'MirrorSyncMode', '*bitmap': 'str',
++ '*bitmap-mode': 'BitmapSyncMode',
+ '*speed': 'int', '*granularity': 'uint32',
+ '*buf-size': 'int', '*on-source-error': 'BlockdevOnError',
+ '*on-target-error': 'BlockdevOnError',
+diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
+index 3f866a35c6..500ede71c8 100644
+--- a/tests/test-block-iothread.c
++++ b/tests/test-block-iothread.c
+@@ -623,8 +623,8 @@ static void test_propagate_mirror(void)
+
+ /* Start a mirror job */
+ mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
+- MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
+- BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
++ MIRROR_SYNC_MODE_NONE, NULL, 0, MIRROR_OPEN_BACKING_CHAIN,
++ false, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
+ false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
+ &error_abort);
+ job = job_get("job0");
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: John Snow <jsnow@redhat.com>
+Date: Mon, 6 Apr 2020 12:17:04 +0200
+Subject: [PATCH] drive-mirror: add support for conditional and always bitmap
+ sync modes
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Teach mirror two new tricks for using bitmaps:
+
+Always: no matter what, we synchronize the copy_bitmap back to the
+sync_bitmap. In effect, this allows us resume a failed mirror at a later
+date.
+
+Conditional: On success only, we sync the bitmap. This is akin to
+incremental backup modes; we can use this bitmap to later refresh a
+successfully created mirror.
+
+Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
+---
+ block/mirror.c | 24 ++++++++++++++++++------
+ 1 file changed, 18 insertions(+), 6 deletions(-)
+
+diff --git a/block/mirror.c b/block/mirror.c
+index 100e828639..7d3c3252f3 100644
+--- a/block/mirror.c
++++ b/block/mirror.c
+@@ -653,8 +653,6 @@ static int mirror_exit_common(Job *job)
+ bdrv_unfreeze_backing_chain(mirror_top_bs, target_bs);
+ }
+
+- bdrv_release_dirty_bitmap(s->dirty_bitmap);
+-
+ /* Make sure that the source BDS doesn't go away during bdrv_replace_node,
+ * before we can call bdrv_drained_end */
+ bdrv_ref(src);
+@@ -752,6 +750,18 @@ static int mirror_exit_common(Job *job)
+ blk_set_perm(bjob->blk, 0, BLK_PERM_ALL, &error_abort);
+ blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
+
++ if (s->sync_bitmap) {
++ if (s->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS ||
++ (s->bitmap_mode == BITMAP_SYNC_MODE_ON_SUCCESS &&
++ job->ret == 0 && ret == 0)) {
++ /* Success; synchronize copy back to sync. */
++ bdrv_clear_dirty_bitmap(s->sync_bitmap, NULL);
++ bdrv_merge_dirty_bitmap(s->sync_bitmap, s->dirty_bitmap,
++ NULL, &error_abort);
++ }
++ }
++ bdrv_release_dirty_bitmap(s->dirty_bitmap);
++
+ bs_opaque->job = NULL;
+
+ bdrv_drained_end(src);
+@@ -1589,10 +1599,6 @@ static BlockJob *mirror_start_job(
+ " sync mode",
+ MirrorSyncMode_str(sync_mode));
+ return NULL;
+- } else if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
+- error_setg(errp,
+- "Bitmap Sync Mode '%s' is not supported by Mirror",
+- BitmapSyncMode_str(bitmap_mode));
+ }
+ } else if (bitmap) {
+ error_setg(errp,
+@@ -1609,6 +1615,12 @@ static BlockJob *mirror_start_job(
+ return NULL;
+ }
+ granularity = bdrv_dirty_bitmap_granularity(bitmap);
++
++ if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
++ if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
++ return NULL;
++ }
++ }
+ } else if (granularity == 0) {
+ granularity = bdrv_get_default_bitmap_granularity(target);
+ }
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: John Snow <jsnow@redhat.com>
-Date: Mon, 6 Apr 2020 12:17:03 +0200
-Subject: [PATCH] drive-mirror: add support for sync=bitmap mode=never
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-This patch adds support for the "BITMAP" sync mode to drive-mirror and
-blockdev-mirror. It adds support only for the BitmapSyncMode "never,"
-because it's the simplest mode.
-
-This mode simply uses a user-provided bitmap as an initial copy
-manifest, and then does not clear any bits in the bitmap at the
-conclusion of the operation.
-
-Any new writes dirtied during the operation are copied out, in contrast
-to backup. Note that whether these writes are reflected in the bitmap
-at the conclusion of the operation depends on whether that bitmap is
-actually recording!
-
-This patch was originally based on one by Ma Haocong, but it has since
-been modified pretty heavily.
-
-Suggested-by: Ma Haocong <mahaocong@didichuxing.com>
-Signed-off-by: Ma Haocong <mahaocong@didichuxing.com>
-Signed-off-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
----
- block/mirror.c | 98 ++++++++++++++++++++++++++++++-------
- blockdev.c | 39 +++++++++++++--
- include/block/block_int.h | 4 +-
- qapi/block-core.json | 29 +++++++++--
- tests/test-block-iothread.c | 4 +-
- 5 files changed, 145 insertions(+), 29 deletions(-)
-
-diff --git a/block/mirror.c b/block/mirror.c
-index e8e8844afc..100e828639 100644
---- a/block/mirror.c
-+++ b/block/mirror.c
-@@ -49,7 +49,7 @@ typedef struct MirrorBlockJob {
- BlockDriverState *to_replace;
- /* Used to block operations on the drive-mirror-replace target */
- Error *replace_blocker;
-- bool is_none_mode;
-+ MirrorSyncMode sync_mode;
- BlockMirrorBackingMode backing_mode;
- /* Whether the target image requires explicit zero-initialization */
- bool zero_target;
-@@ -64,6 +64,8 @@ typedef struct MirrorBlockJob {
- size_t buf_size;
- int64_t bdev_length;
- unsigned long *cow_bitmap;
-+ BdrvDirtyBitmap *sync_bitmap;
-+ BitmapSyncMode bitmap_mode;
- BdrvDirtyBitmap *dirty_bitmap;
- BdrvDirtyBitmapIter *dbi;
- uint8_t *buf;
-@@ -676,7 +678,8 @@ static int mirror_exit_common(Job *job)
- bdrv_child_refresh_perms(mirror_top_bs, mirror_top_bs->backing,
- &error_abort);
- if (!abort && s->backing_mode == MIRROR_SOURCE_BACKING_CHAIN) {
-- BlockDriverState *backing = s->is_none_mode ? src : s->base;
-+ BlockDriverState *backing;
-+ backing = s->sync_mode == MIRROR_SYNC_MODE_NONE ? src : s->base;
- if (backing_bs(target_bs) != backing) {
- bdrv_set_backing_hd(target_bs, backing, &local_err);
- if (local_err) {
-@@ -771,6 +774,16 @@ static void mirror_abort(Job *job)
- assert(ret == 0);
- }
-
-+/* Always called after commit/abort. */
-+static void mirror_clean(Job *job)
-+{
-+ MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
-+
-+ if (s->sync_bitmap) {
-+ bdrv_dirty_bitmap_set_busy(s->sync_bitmap, false);
-+ }
-+}
-+
- static void coroutine_fn mirror_throttle(MirrorBlockJob *s)
- {
- int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
-@@ -952,7 +965,8 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
- mirror_free_init(s);
-
- s->last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
-- if (!s->is_none_mode) {
-+ if ((s->sync_mode == MIRROR_SYNC_MODE_TOP) ||
-+ (s->sync_mode == MIRROR_SYNC_MODE_FULL)) {
- ret = mirror_dirty_init(s);
- if (ret < 0 || job_is_cancelled(&s->common.job)) {
- goto immediate_exit;
-@@ -1184,6 +1198,7 @@ static const BlockJobDriver mirror_job_driver = {
- .run = mirror_run,
- .prepare = mirror_prepare,
- .abort = mirror_abort,
-+ .clean = mirror_clean,
- .pause = mirror_pause,
- .complete = mirror_complete,
- },
-@@ -1199,6 +1214,7 @@ static const BlockJobDriver commit_active_job_driver = {
- .run = mirror_run,
- .prepare = mirror_prepare,
- .abort = mirror_abort,
-+ .clean = mirror_clean,
- .pause = mirror_pause,
- .complete = mirror_complete,
- },
-@@ -1547,7 +1563,10 @@ static BlockJob *mirror_start_job(
- BlockCompletionFunc *cb,
- void *opaque,
- const BlockJobDriver *driver,
-- bool is_none_mode, BlockDriverState *base,
-+ MirrorSyncMode sync_mode,
-+ BdrvDirtyBitmap *bitmap,
-+ BitmapSyncMode bitmap_mode,
-+ BlockDriverState *base,
- bool auto_complete, const char *filter_node_name,
- bool is_mirror, MirrorCopyMode copy_mode,
- Error **errp)
-@@ -1560,10 +1579,39 @@ static BlockJob *mirror_start_job(
- Error *local_err = NULL;
- int ret;
-
-- if (granularity == 0) {
-- granularity = bdrv_get_default_bitmap_granularity(target);
-+ if (sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
-+ error_setg(errp, "Sync mode '%s' not supported",
-+ MirrorSyncMode_str(sync_mode));
-+ return NULL;
-+ } else if (sync_mode == MIRROR_SYNC_MODE_BITMAP) {
-+ if (!bitmap) {
-+ error_setg(errp, "Must provide a valid bitmap name for '%s'"
-+ " sync mode",
-+ MirrorSyncMode_str(sync_mode));
-+ return NULL;
-+ } else if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
-+ error_setg(errp,
-+ "Bitmap Sync Mode '%s' is not supported by Mirror",
-+ BitmapSyncMode_str(bitmap_mode));
-+ }
-+ } else if (bitmap) {
-+ error_setg(errp,
-+ "sync mode '%s' is not compatible with bitmaps",
-+ MirrorSyncMode_str(sync_mode));
-+ return NULL;
- }
-
-+ if (bitmap) {
-+ if (granularity) {
-+ error_setg(errp, "granularity (%d)"
-+ "cannot be specified when a bitmap is provided",
-+ granularity);
-+ return NULL;
-+ }
-+ granularity = bdrv_dirty_bitmap_granularity(bitmap);
-+ } else if (granularity == 0) {
-+ granularity = bdrv_get_default_bitmap_granularity(target);
-+ }
- assert(is_power_of_2(granularity));
-
- if (buf_size < 0) {
-@@ -1667,7 +1715,9 @@ static BlockJob *mirror_start_job(
- s->replaces = g_strdup(replaces);
- s->on_source_error = on_source_error;
- s->on_target_error = on_target_error;
-- s->is_none_mode = is_none_mode;
-+ s->sync_mode = sync_mode;
-+ s->sync_bitmap = bitmap;
-+ s->bitmap_mode = bitmap_mode;
- s->backing_mode = backing_mode;
- s->zero_target = zero_target;
- s->copy_mode = copy_mode;
-@@ -1687,6 +1737,18 @@ static BlockJob *mirror_start_job(
- bdrv_disable_dirty_bitmap(s->dirty_bitmap);
- }
-
-+ if (s->sync_bitmap) {
-+ bdrv_dirty_bitmap_set_busy(s->sync_bitmap, true);
-+ }
-+
-+ if (s->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
-+ bdrv_merge_dirty_bitmap(s->dirty_bitmap, s->sync_bitmap,
-+ NULL, &local_err);
-+ if (local_err) {
-+ goto fail;
-+ }
-+ }
-+
- ret = block_job_add_bdrv(&s->common, "source", bs, 0,
- BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE |
- BLK_PERM_CONSISTENT_READ,
-@@ -1740,6 +1802,9 @@ fail:
- if (s->dirty_bitmap) {
- bdrv_release_dirty_bitmap(s->dirty_bitmap);
- }
-+ if (s->sync_bitmap) {
-+ bdrv_dirty_bitmap_set_busy(s->sync_bitmap, false);
-+ }
- job_early_fail(&s->common.job);
- }
-
-@@ -1757,29 +1822,23 @@ void mirror_start(const char *job_id, BlockDriverState *bs,
- BlockDriverState *target, const char *replaces,
- int creation_flags, int64_t speed,
- uint32_t granularity, int64_t buf_size,
-- MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
-+ MirrorSyncMode mode, BdrvDirtyBitmap *bitmap,
-+ BitmapSyncMode bitmap_mode,
-+ BlockMirrorBackingMode backing_mode,
- bool zero_target,
- BlockdevOnError on_source_error,
- BlockdevOnError on_target_error,
- bool unmap, const char *filter_node_name,
- MirrorCopyMode copy_mode, Error **errp)
- {
-- bool is_none_mode;
- BlockDriverState *base;
-
-- if ((mode == MIRROR_SYNC_MODE_INCREMENTAL) ||
-- (mode == MIRROR_SYNC_MODE_BITMAP)) {
-- error_setg(errp, "Sync mode '%s' not supported",
-- MirrorSyncMode_str(mode));
-- return;
-- }
-- is_none_mode = mode == MIRROR_SYNC_MODE_NONE;
- base = mode == MIRROR_SYNC_MODE_TOP ? backing_bs(bs) : NULL;
- mirror_start_job(job_id, bs, creation_flags, target, replaces,
- speed, granularity, buf_size, backing_mode, zero_target,
- on_source_error, on_target_error, unmap, NULL, NULL,
-- &mirror_job_driver, is_none_mode, base, false,
-- filter_node_name, true, copy_mode, errp);
-+ &mirror_job_driver, mode, bitmap, bitmap_mode, base,
-+ false, filter_node_name, true, copy_mode, errp);
- }
-
- BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
-@@ -1805,7 +1864,8 @@ BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs,
- job_id, bs, creation_flags, base, NULL, speed, 0, 0,
- MIRROR_LEAVE_BACKING_CHAIN, false,
- on_error, on_error, true, cb, opaque,
-- &commit_active_job_driver, false, base, auto_complete,
-+ &commit_active_job_driver, MIRROR_SYNC_MODE_FULL,
-+ NULL, 0, base, auto_complete,
- filter_node_name, false, MIRROR_COPY_MODE_BACKGROUND,
- &local_err);
- if (local_err) {
-diff --git a/blockdev.c b/blockdev.c
-index 3c427fc4be..28ed750ba5 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -2877,6 +2877,10 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
- BlockDriverState *target,
- bool has_replaces, const char *replaces,
- enum MirrorSyncMode sync,
-+ bool has_bitmap,
-+ const char *bitmap_name,
-+ bool has_bitmap_mode,
-+ BitmapSyncMode bitmap_mode,
- BlockMirrorBackingMode backing_mode,
- bool zero_target,
- bool has_speed, int64_t speed,
-@@ -2895,6 +2899,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
- Error **errp)
- {
- int job_flags = JOB_DEFAULT;
-+ BdrvDirtyBitmap *bitmap = NULL;
-
- if (!has_speed) {
- speed = 0;
-@@ -2949,6 +2954,29 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
- sync = MIRROR_SYNC_MODE_FULL;
- }
-
-+ if (has_bitmap) {
-+ if (granularity) {
-+ error_setg(errp, "Granularity and bitmap cannot both be set");
-+ return;
-+ }
-+
-+ if (!has_bitmap_mode) {
-+ error_setg(errp, "bitmap-mode must be specified if"
-+ " a bitmap is provided");
-+ return;
-+ }
-+
-+ bitmap = bdrv_find_dirty_bitmap(bs, bitmap_name);
-+ if (!bitmap) {
-+ error_setg(errp, "Dirty bitmap '%s' not found", bitmap_name);
-+ return;
-+ }
-+
-+ if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
-+ return;
-+ }
-+ }
-+
- if (has_replaces) {
- BlockDriverState *to_replace_bs;
- AioContext *replace_aio_context;
-@@ -2986,8 +3014,8 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
- * and will allow to check whether the node still exist at mirror completion
- */
- mirror_start(job_id, bs, target,
-- has_replaces ? replaces : NULL, job_flags,
-- speed, granularity, buf_size, sync, backing_mode, zero_target,
-+ has_replaces ? replaces : NULL, job_flags, speed, granularity,
-+ buf_size, sync, bitmap, bitmap_mode, backing_mode, zero_target,
- on_source_error, on_target_error, unmap, filter_node_name,
- copy_mode, errp);
- }
-@@ -3128,6 +3156,8 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
-
- blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs,
- arg->has_replaces, arg->replaces, arg->sync,
-+ arg->has_bitmap, arg->bitmap,
-+ arg->has_bitmap_mode, arg->bitmap_mode,
- backing_mode, zero_target,
- arg->has_speed, arg->speed,
- arg->has_granularity, arg->granularity,
-@@ -3149,6 +3179,8 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
- const char *device, const char *target,
- bool has_replaces, const char *replaces,
- MirrorSyncMode sync,
-+ bool has_bitmap, const char *bitmap,
-+ bool has_bitmap_mode, BitmapSyncMode bitmap_mode,
- bool has_speed, int64_t speed,
- bool has_granularity, uint32_t granularity,
- bool has_buf_size, int64_t buf_size,
-@@ -3198,7 +3230,8 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
- }
-
- blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs,
-- has_replaces, replaces, sync, backing_mode,
-+ has_replaces, replaces, sync, has_bitmap,
-+ bitmap, has_bitmap_mode, bitmap_mode, backing_mode,
- zero_target, has_speed, speed,
- has_granularity, granularity,
- has_buf_size, buf_size,
-diff --git a/include/block/block_int.h b/include/block/block_int.h
-index 5ff3b1186f..befdae125b 100644
---- a/include/block/block_int.h
-+++ b/include/block/block_int.h
-@@ -1245,7 +1245,9 @@ void mirror_start(const char *job_id, BlockDriverState *bs,
- BlockDriverState *target, const char *replaces,
- int creation_flags, int64_t speed,
- uint32_t granularity, int64_t buf_size,
-- MirrorSyncMode mode, BlockMirrorBackingMode backing_mode,
-+ MirrorSyncMode mode, BdrvDirtyBitmap *bitmap,
-+ BitmapSyncMode bitmap_mode,
-+ BlockMirrorBackingMode backing_mode,
- bool zero_target,
- BlockdevOnError on_source_error,
- BlockdevOnError on_target_error,
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index 69db270b1a..9db8e26517 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -2064,10 +2064,19 @@
- # (all the disk, only the sectors allocated in the topmost image, or
- # only new I/O).
- #
-+# @bitmap: The name of a bitmap to use for sync=bitmap mode. This argument must
-+# be present for bitmap mode and absent otherwise. The bitmap's
-+# granularity is used instead of @granularity (since 4.1).
-+#
-+# @bitmap-mode: Specifies the type of data the bitmap should contain after
-+# the operation concludes. Must be present if sync is "bitmap".
-+# Must NOT be present otherwise. (Since 4.1)
-+#
- # @granularity: granularity of the dirty bitmap, default is 64K
- # if the image format doesn't have clusters, 4K if the clusters
- # are smaller than that, else the cluster size. Must be a
--# power of 2 between 512 and 64M (since 1.4).
-+# power of 2 between 512 and 64M. Must not be specified if
-+# @bitmap is present (since 1.4).
- #
- # @buf-size: maximum amount of data in flight from source to
- # target (since 1.4).
-@@ -2105,7 +2114,9 @@
- { 'struct': 'DriveMirror',
- 'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
- '*format': 'str', '*node-name': 'str', '*replaces': 'str',
-- 'sync': 'MirrorSyncMode', '*mode': 'NewImageMode',
-+ 'sync': 'MirrorSyncMode', '*bitmap': 'str',
-+ '*bitmap-mode': 'BitmapSyncMode',
-+ '*mode': 'NewImageMode',
- '*speed': 'int', '*granularity': 'uint32',
- '*buf-size': 'int', '*on-source-error': 'BlockdevOnError',
- '*on-target-error': 'BlockdevOnError',
-@@ -2372,10 +2383,19 @@
- # (all the disk, only the sectors allocated in the topmost image, or
- # only new I/O).
- #
-+# @bitmap: The name of a bitmap to use for sync=bitmap mode. This argument must
-+# be present for bitmap mode and absent otherwise. The bitmap's
-+# granularity is used instead of @granularity (since 4.1).
-+#
-+# @bitmap-mode: Specifies the type of data the bitmap should contain after
-+# the operation concludes. Must be present if sync is "bitmap".
-+# Must NOT be present otherwise. (Since 4.1)
-+#
- # @granularity: granularity of the dirty bitmap, default is 64K
- # if the image format doesn't have clusters, 4K if the clusters
- # are smaller than that, else the cluster size. Must be a
--# power of 2 between 512 and 64M
-+# power of 2 between 512 and 64M . Must not be specified if
-+# @bitmap is present.
- #
- # @buf-size: maximum amount of data in flight from source to
- # target
-@@ -2424,7 +2444,8 @@
- { 'command': 'blockdev-mirror',
- 'data': { '*job-id': 'str', 'device': 'str', 'target': 'str',
- '*replaces': 'str',
-- 'sync': 'MirrorSyncMode',
-+ 'sync': 'MirrorSyncMode', '*bitmap': 'str',
-+ '*bitmap-mode': 'BitmapSyncMode',
- '*speed': 'int', '*granularity': 'uint32',
- '*buf-size': 'int', '*on-source-error': 'BlockdevOnError',
- '*on-target-error': 'BlockdevOnError',
-diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
-index 3f866a35c6..500ede71c8 100644
---- a/tests/test-block-iothread.c
-+++ b/tests/test-block-iothread.c
-@@ -623,8 +623,8 @@ static void test_propagate_mirror(void)
-
- /* Start a mirror job */
- mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
-- MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
-- BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
-+ MIRROR_SYNC_MODE_NONE, NULL, 0, MIRROR_OPEN_BACKING_CHAIN,
-+ false, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
- false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
- &error_abort);
- job = job_get("job0");
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: John Snow <jsnow@redhat.com>
-Date: Mon, 6 Apr 2020 12:17:04 +0200
-Subject: [PATCH] drive-mirror: add support for conditional and always bitmap
- sync modes
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Teach mirror two new tricks for using bitmaps:
-
-Always: no matter what, we synchronize the copy_bitmap back to the
-sync_bitmap. In effect, this allows us resume a failed mirror at a later
-date.
-
-Conditional: On success only, we sync the bitmap. This is akin to
-incremental backup modes; we can use this bitmap to later refresh a
-successfully created mirror.
-
-Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
----
- block/mirror.c | 24 ++++++++++++++++++------
- 1 file changed, 18 insertions(+), 6 deletions(-)
-
-diff --git a/block/mirror.c b/block/mirror.c
-index 100e828639..7d3c3252f3 100644
---- a/block/mirror.c
-+++ b/block/mirror.c
-@@ -653,8 +653,6 @@ static int mirror_exit_common(Job *job)
- bdrv_unfreeze_backing_chain(mirror_top_bs, target_bs);
- }
-
-- bdrv_release_dirty_bitmap(s->dirty_bitmap);
--
- /* Make sure that the source BDS doesn't go away during bdrv_replace_node,
- * before we can call bdrv_drained_end */
- bdrv_ref(src);
-@@ -752,6 +750,18 @@ static int mirror_exit_common(Job *job)
- blk_set_perm(bjob->blk, 0, BLK_PERM_ALL, &error_abort);
- blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
-
-+ if (s->sync_bitmap) {
-+ if (s->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS ||
-+ (s->bitmap_mode == BITMAP_SYNC_MODE_ON_SUCCESS &&
-+ job->ret == 0 && ret == 0)) {
-+ /* Success; synchronize copy back to sync. */
-+ bdrv_clear_dirty_bitmap(s->sync_bitmap, NULL);
-+ bdrv_merge_dirty_bitmap(s->sync_bitmap, s->dirty_bitmap,
-+ NULL, &error_abort);
-+ }
-+ }
-+ bdrv_release_dirty_bitmap(s->dirty_bitmap);
-+
- bs_opaque->job = NULL;
-
- bdrv_drained_end(src);
-@@ -1589,10 +1599,6 @@ static BlockJob *mirror_start_job(
- " sync mode",
- MirrorSyncMode_str(sync_mode));
- return NULL;
-- } else if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
-- error_setg(errp,
-- "Bitmap Sync Mode '%s' is not supported by Mirror",
-- BitmapSyncMode_str(bitmap_mode));
- }
- } else if (bitmap) {
- error_setg(errp,
-@@ -1609,6 +1615,12 @@ static BlockJob *mirror_start_job(
- return NULL;
- }
- granularity = bdrv_dirty_bitmap_granularity(bitmap);
-+
-+ if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
-+ if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
-+ return NULL;
-+ }
-+ }
- } else if (granularity == 0) {
- granularity = bdrv_get_default_bitmap_granularity(target);
- }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
+Date: Mon, 6 Apr 2020 12:17:05 +0200
+Subject: [PATCH] mirror: add check for bitmap-mode without bitmap
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+as one without the other does not make much sense with the current set
+of modes.
+
+Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
+---
+ blockdev.c | 3 +++
+ 1 file changed, 3 insertions(+)
+
+diff --git a/blockdev.c b/blockdev.c
+index 02d58e7645..0d480f02c7 100644
+--- a/blockdev.c
++++ b/blockdev.c
+@@ -2974,6 +2974,9 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
+ if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
+ return;
+ }
++ } else if (has_bitmap_mode) {
++ error_setg(errp, "Cannot specify bitmap sync mode without a bitmap");
++ return;
+ }
+
+ if (has_replaces) {
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
-Date: Mon, 6 Apr 2020 12:17:05 +0200
-Subject: [PATCH] mirror: add check for bitmap-mode without bitmap
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-as one without the other does not make much sense with the current set
-of modes.
-
-Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
----
- blockdev.c | 3 +++
- 1 file changed, 3 insertions(+)
-
-diff --git a/blockdev.c b/blockdev.c
-index 28ed750ba5..4665321bd8 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -2975,6 +2975,9 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
- if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
- return;
- }
-+ } else if (has_bitmap_mode) {
-+ error_setg(errp, "Cannot specify bitmap sync mode without a bitmap");
-+ return;
- }
-
- if (has_replaces) {
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
+Date: Mon, 6 Apr 2020 12:17:06 +0200
+Subject: [PATCH] mirror: switch to bdrv_dirty_bitmap_merge_internal
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+since sync_bitmap is busy at the point of merging, and we checked access
+beforehand.
+
+Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
+---
+ block/mirror.c | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/block/mirror.c b/block/mirror.c
+index 7d3c3252f3..fb12ccb932 100644
+--- a/block/mirror.c
++++ b/block/mirror.c
+@@ -756,8 +756,8 @@ static int mirror_exit_common(Job *job)
+ job->ret == 0 && ret == 0)) {
+ /* Success; synchronize copy back to sync. */
+ bdrv_clear_dirty_bitmap(s->sync_bitmap, NULL);
+- bdrv_merge_dirty_bitmap(s->sync_bitmap, s->dirty_bitmap,
+- NULL, &error_abort);
++ bdrv_dirty_bitmap_merge_internal(s->sync_bitmap, s->dirty_bitmap,
++ NULL, true);
+ }
+ }
+ bdrv_release_dirty_bitmap(s->dirty_bitmap);
+@@ -1754,8 +1754,8 @@ static BlockJob *mirror_start_job(
+ }
+
+ if (s->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
+- bdrv_merge_dirty_bitmap(s->dirty_bitmap, s->sync_bitmap,
+- NULL, &local_err);
++ bdrv_dirty_bitmap_merge_internal(s->dirty_bitmap, s->sync_bitmap,
++ NULL, true);
+ if (local_err) {
+ goto fail;
+ }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
+Date: Mon, 6 Apr 2020 12:17:07 +0200
+Subject: [PATCH] iotests: add test for bitmap mirror
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+heavily based on/practically forked off iotest 257 for bitmap backups,
+but:
+
+- no writes to filter node 'mirror-top' between completion and
+finalization, as those seem to deadlock?
+- no inclusion of not-yet-available full/top sync modes in combination
+with bitmaps
+- extra set of reference/test mirrors to verify that writes in parallel
+with active mirror work
+
+intentionally keeping copyright and ownership of original test case to
+honor provenance.
+
+Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
+---
+ tests/qemu-iotests/384 | 547 +++++++
+ tests/qemu-iotests/384.out | 2846 ++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/group | 1 +
+ 3 files changed, 3394 insertions(+)
+ create mode 100755 tests/qemu-iotests/384
+ create mode 100644 tests/qemu-iotests/384.out
+
+diff --git a/tests/qemu-iotests/384 b/tests/qemu-iotests/384
+new file mode 100755
+index 0000000000..b04a8e651a
+--- /dev/null
++++ b/tests/qemu-iotests/384
+@@ -0,0 +1,547 @@
++#!/usr/bin/env python3
++#
++# Test bitmap-sync mirrors (incremental, differential, and partials)
++#
++# Copyright (c) 2019 John Snow for Red Hat, Inc.
++#
++# This program is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 2 of the License, or
++# (at your option) any later version.
++#
++# This program 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 General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program. If not, see <http://www.gnu.org/licenses/>.
++#
++# owner=jsnow@redhat.com
++
++import math
++import os
++
++import iotests
++from iotests import log, qemu_img
++
++SIZE = 64 * 1024 * 1024
++GRANULARITY = 64 * 1024
++
++
++class Pattern:
++ def __init__(self, byte, offset, size=GRANULARITY):
++ self.byte = byte
++ self.offset = offset
++ self.size = size
++
++ def bits(self, granularity):
++ lower = self.offset // granularity
++ upper = (self.offset + self.size - 1) // granularity
++ return set(range(lower, upper + 1))
++
++
++class PatternGroup:
++ """Grouping of Pattern objects. Initialize with an iterable of Patterns."""
++ def __init__(self, patterns):
++ self.patterns = patterns
++
++ def bits(self, granularity):
++ """Calculate the unique bits dirtied by this pattern grouping"""
++ res = set()
++ for pattern in self.patterns:
++ res |= pattern.bits(granularity)
++ return res
++
++
++GROUPS = [
++ PatternGroup([
++ # Batch 0: 4 clusters
++ Pattern('0x49', 0x0000000),
++ Pattern('0x6c', 0x0100000), # 1M
++ Pattern('0x6f', 0x2000000), # 32M
++ Pattern('0x76', 0x3ff0000)]), # 64M - 64K
++ PatternGroup([
++ # Batch 1: 6 clusters (3 new)
++ Pattern('0x65', 0x0000000), # Full overwrite
++ Pattern('0x77', 0x00f8000), # Partial-left (1M-32K)
++ Pattern('0x72', 0x2008000), # Partial-right (32M+32K)
++ Pattern('0x69', 0x3fe0000)]), # Adjacent-left (64M - 128K)
++ PatternGroup([
++ # Batch 2: 7 clusters (3 new)
++ Pattern('0x74', 0x0010000), # Adjacent-right
++ Pattern('0x69', 0x00e8000), # Partial-left (1M-96K)
++ Pattern('0x6e', 0x2018000), # Partial-right (32M+96K)
++ Pattern('0x67', 0x3fe0000,
++ 2*GRANULARITY)]), # Overwrite [(64M-128K)-64M)
++ PatternGroup([
++ # Batch 3: 8 clusters (5 new)
++ # Carefully chosen such that nothing re-dirties the one cluster
++ # that copies out successfully before failure in Group #1.
++ Pattern('0xaa', 0x0010000,
++ 3*GRANULARITY), # Overwrite and 2x Adjacent-right
++ Pattern('0xbb', 0x00d8000), # Partial-left (1M-160K)
++ Pattern('0xcc', 0x2028000), # Partial-right (32M+160K)
++ Pattern('0xdd', 0x3fc0000)]), # New; leaving a gap to the right
++]
++
++
++class EmulatedBitmap:
++ def __init__(self, granularity=GRANULARITY):
++ self._bits = set()
++ self.granularity = granularity
++
++ def dirty_bits(self, bits):
++ self._bits |= set(bits)
++
++ def dirty_group(self, n):
++ self.dirty_bits(GROUPS[n].bits(self.granularity))
++
++ def clear(self):
++ self._bits = set()
++
++ def clear_bits(self, bits):
++ self._bits -= set(bits)
++
++ def clear_bit(self, bit):
++ self.clear_bits({bit})
++
++ def clear_group(self, n):
++ self.clear_bits(GROUPS[n].bits(self.granularity))
++
++ @property
++ def first_bit(self):
++ return sorted(self.bits)[0]
++
++ @property
++ def bits(self):
++ return self._bits
++
++ @property
++ def count(self):
++ return len(self.bits)
++
++ def compare(self, qmp_bitmap):
++ """
++ Print a nice human-readable message checking that a bitmap as reported
++ by the QMP interface has as many bits set as we expect it to.
++ """
++
++ name = qmp_bitmap.get('name', '(anonymous)')
++ log("= Checking Bitmap {:s} =".format(name))
++
++ want = self.count
++ have = qmp_bitmap['count'] // qmp_bitmap['granularity']
++
++ log("expecting {:d} dirty sectors; have {:d}. {:s}".format(
++ want, have, "OK!" if want == have else "ERROR!"))
++ log('')
++
++
++class Drive:
++ """Represents, vaguely, a drive attached to a VM.
++ Includes format, graph, and device information."""
++
++ def __init__(self, path, vm=None):
++ self.path = path
++ self.vm = vm
++ self.fmt = None
++ self.size = None
++ self.node = None
++
++ def img_create(self, fmt, size):
++ self.fmt = fmt
++ self.size = size
++ iotests.qemu_img_create('-f', self.fmt, self.path, str(self.size))
++
++ def create_target(self, name, fmt, size):
++ basename = os.path.basename(self.path)
++ file_node_name = "file_{}".format(basename)
++ vm = self.vm
++
++ log(vm.command('blockdev-create', job_id='bdc-file-job',
++ options={
++ 'driver': 'file',
++ 'filename': self.path,
++ 'size': 0,
++ }))
++ vm.run_job('bdc-file-job')
++ log(vm.command('blockdev-add', driver='file',
++ node_name=file_node_name, filename=self.path))
++
++ log(vm.command('blockdev-create', job_id='bdc-fmt-job',
++ options={
++ 'driver': fmt,
++ 'file': file_node_name,
++ 'size': size,
++ }))
++ vm.run_job('bdc-fmt-job')
++ log(vm.command('blockdev-add', driver=fmt,
++ node_name=name,
++ file=file_node_name))
++ self.fmt = fmt
++ self.size = size
++ self.node = name
++
++def blockdev_mirror(vm, device, target, sync, **kwargs):
++ # Strip any arguments explicitly nulled by the caller:
++ kwargs = {key: val for key, val in kwargs.items() if val is not None}
++ result = vm.qmp_log('blockdev-mirror',
++ device=device,
++ target=target,
++ sync=sync,
++ filter_node_name='mirror-top',
++ **kwargs)
++ return result
++
++def blockdev_mirror_mktarget(drive, target_id, filepath, sync, **kwargs):
++ target_drive = Drive(filepath, vm=drive.vm)
++ target_drive.create_target(target_id, drive.fmt, drive.size)
++ blockdev_mirror(drive.vm, drive.node, target_id, sync, **kwargs)
++
++def reference_mirror(drive, n, filepath):
++ log("--- Reference mirror #{:d} ---\n".format(n))
++ target_id = "ref_target_{:d}".format(n)
++ job_id = "ref_mirror_{:d}".format(n)
++ blockdev_mirror_mktarget(drive, target_id, filepath, "full",
++ job_id=job_id)
++ drive.vm.run_job(job_id, auto_dismiss=True)
++ log('')
++
++def mirror(drive, n, filepath, sync, **kwargs):
++ log("--- Test mirror #{:d} ---\n".format(n))
++ target_id = "mirror_target_{:d}".format(n)
++ job_id = "mirror_{:d}".format(n)
++ kwargs.setdefault('auto-finalize', False)
++ blockdev_mirror_mktarget(drive, target_id, filepath, sync,
++ job_id=job_id, **kwargs)
++ return job_id
++
++def perform_writes(drive, n, filter_node_name=None):
++ log("--- Write #{:d} ---\n".format(n))
++ for pattern in GROUPS[n].patterns:
++ cmd = "write -P{:s} 0x{:07x} 0x{:x}".format(
++ pattern.byte,
++ pattern.offset,
++ pattern.size)
++ log(cmd)
++ log(drive.vm.hmp_qemu_io(filter_node_name or drive.node, cmd))
++ bitmaps = drive.vm.query_bitmaps()
++ log({'bitmaps': bitmaps}, indent=2)
++ log('')
++ return bitmaps
++
++
++def compare_images(image, reference, baseimg=None, expected_match=True):
++ """
++ Print a nice human-readable message comparing these images.
++ """
++ expected_ret = 0 if expected_match else 1
++ if baseimg:
++ assert qemu_img("rebase", "-u", "-b", baseimg, image) == 0
++ ret = qemu_img("compare", image, reference)
++ log('qemu_img compare "{:s}" "{:s}" ==> {:s}, {:s}'.format(
++ image, reference,
++ "Identical" if ret == 0 else "Mismatch",
++ "OK!" if ret == expected_ret else "ERROR!"),
++ filters=[iotests.filter_testfiles])
++
++def test_bitmap_sync(bsync_mode, msync_mode='bitmap', failure=None):
++ """
++ Test bitmap mirror routines.
++
++ :param bsync_mode: Is the Bitmap Sync mode, and can be any of:
++ - on-success: This is the "incremental" style mode. Bitmaps are
++ synchronized to what was copied out only on success.
++ (Partial images must be discarded.)
++ - never: This is the "differential" style mode.
++ Bitmaps are never synchronized.
++ - always: This is a "best effort" style mode.
++ Bitmaps are always synchronized, regardless of failure.
++ (Partial images must be kept.)
++
++ :param msync_mode: The mirror sync mode to use for the first mirror.
++ Can be any one of:
++ - bitmap: mirrors based on bitmap manifest.
++ - full: Full mirrors.
++ - top: Full mirrors of the top layer only.
++
++ :param failure: Is the (optional) failure mode, and can be any of:
++ - None: No failure. Test the normative path. Default.
++ - simulated: Cancel the job right before it completes.
++ This also tests writes "during" the job.
++ - intermediate: This tests a job that fails mid-process and produces
++ an incomplete mirror. Testing limitations prevent
++ testing competing writes.
++ """
++ with iotests.FilePaths(['img', 'bsync1', 'bsync2', 'bsync3',
++ 'fmirror0', 'fmirror1', 'fmirror2', 'fmirror3']) as \
++ (img_path, bsync1, bsync2, bsync3,
++ fmirror0, fmirror1, fmirror2, fmirror3), \
++ iotests.VM() as vm:
++
++ mode = "Mode {:s}; Bitmap Sync {:s}".format(msync_mode, bsync_mode)
++ preposition = "with" if failure else "without"
++ cond = "{:s} {:s}".format(preposition,
++ "{:s} failure".format(failure) if failure
++ else "failure")
++ log("\n=== {:s} {:s} ===\n".format(mode, cond))
++
++ log('--- Preparing image & VM ---\n')
++ drive0 = Drive(img_path, vm=vm)
++ drive0.img_create(iotests.imgfmt, SIZE)
++ vm.add_device("{},id=scsi0".format(iotests.get_virtio_scsi_device()))
++ vm.launch()
++
++ file_config = {
++ 'driver': 'file',
++ 'filename': drive0.path
++ }
++
++ if failure == 'intermediate':
++ file_config = {
++ 'driver': 'blkdebug',
++ 'image': file_config,
++ 'set-state': [{
++ 'event': 'flush_to_disk',
++ 'state': 1,
++ 'new_state': 2
++ }, {
++ 'event': 'read_aio',
++ 'state': 2,
++ 'new_state': 3
++ }, {
++ 'event': 'read_aio',
++ 'state': 3,
++ 'new_state': 4
++ }],
++ 'inject-error': [{
++ 'event': 'read_aio',
++ 'errno': 5,
++ 'state': 3,
++ 'immediately': False,
++ 'once': True
++ }, {
++ 'event': 'read_aio',
++ 'errno': 5,
++ 'state': 4,
++ 'immediately': False,
++ 'once': True
++ }]
++ }
++
++ drive0.node = 'drive0'
++ vm.qmp_log('blockdev-add',
++ filters=[iotests.filter_qmp_testfiles],
++ node_name=drive0.node,
++ driver=drive0.fmt,
++ file=file_config)
++ log('')
++
++ # 0 - Writes and Reference mirror
++ perform_writes(drive0, 0)
++ reference_mirror(drive0, 0, fmirror0)
++ log('--- Add Bitmap ---\n')
++ vm.qmp_log("block-dirty-bitmap-add", node=drive0.node,
++ name="bitmap0", granularity=GRANULARITY)
++ log('')
++ ebitmap = EmulatedBitmap()
++
++ # 1 - Writes and Reference mirror
++ bitmaps = perform_writes(drive0, 1)
++ ebitmap.dirty_group(1)
++ bitmap = vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps)
++ ebitmap.compare(bitmap)
++ reference_mirror(drive0, 1, fmirror1)
++
++ # 1 - Test mirror (w/ Optional induced failure)
++ if failure == 'intermediate':
++ # Activate blkdebug induced failure for second-to-next read
++ log(vm.hmp_qemu_io(drive0.node, 'flush'))
++ log('')
++ job = mirror(drive0, 1, bsync1, msync_mode,
++ bitmap="bitmap0", bitmap_mode=bsync_mode)
++
++ vm.run_job(job, auto_dismiss=True, auto_finalize=False,
++ cancel=(failure == 'simulated'))
++ bitmaps = vm.query_bitmaps()
++ log({'bitmaps': bitmaps}, indent=2)
++ log('')
++
++ if bsync_mode == 'always':
++ if failure == 'intermediate':
++ # We manage to copy one sector (one bit) before the error.
++ ebitmap.clear_bit(ebitmap.first_bit)
++ else:
++ # successful mirror / cancelled complete mirror
++ ebitmap.clear()
++
++ if bsync_mode == 'on-success' and not failure:
++ ebitmap.clear()
++
++ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
++
++ # 2 - Reference mirror
++ reference_mirror(drive0, 2, fmirror2)
++
++ # 2 - Bitmap mirror with writes before completion
++ job = mirror(drive0, 2, bsync2, "bitmap",
++ bitmap="bitmap0", bitmap_mode=bsync_mode)
++
++ bitmaps = perform_writes(drive0, 2)
++ ebitmap.dirty_group(2)
++ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
++
++ # don't use run_job as that logs too much even with use_log=False
++ events = [('JOB_STATUS_CHANGE', {'data': {'id': job}})]
++ while True:
++ ev = iotests.filter_qmp_event(vm.events_wait(events, timeout=10))
++ status = ev['data']['status']
++ if status == 'ready':
++ vm.qmp('job-complete', id=job)
++ elif status == 'standby':
++ vm.qmp('job-resume', id=job)
++ elif status == 'pending':
++ vm.qmp('job-finalize', id=job)
++ elif status == 'null':
++ break
++
++ if bsync_mode != 'never':
++ ebitmap.clear()
++
++ bitmaps = vm.query_bitmaps()
++ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
++
++ # 3 - Writes and Reference mirror
++ bitmaps = perform_writes(drive0, 3)
++ ebitmap.dirty_group(3)
++ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
++ reference_mirror(drive0, 3, fmirror3)
++
++ # 3 - Bitmap mirror (In failure modes, this is a recovery.)
++ job = mirror(drive0, 3, bsync3, "bitmap",
++ bitmap="bitmap0", bitmap_mode=bsync_mode)
++
++ vm.run_job(job, auto_dismiss=True, auto_finalize=False)
++ bitmaps = vm.query_bitmaps()
++
++ log({'bitmaps': bitmaps}, indent=2)
++ log('')
++ if bsync_mode != 'never':
++ ebitmap.clear()
++ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
++
++ log('--- Cleanup ---\n')
++ vm.qmp_log("block-dirty-bitmap-remove",
++ node=drive0.node, name="bitmap0")
++ bitmaps = vm.query_bitmaps()
++ log({'bitmaps': bitmaps}, indent=2)
++ vm.shutdown()
++ log('')
++
++ log('--- Verification ---\n')
++ compare_images(bsync1, fmirror1, baseimg=fmirror0,
++ expected_match=failure != 'intermediate')
++ if not failure or bsync_mode == 'always':
++ # Always keep the last mirror on success or when using 'always'
++ base = bsync1
++ else:
++ base = fmirror1
++
++ compare_images(bsync2, fmirror2, baseimg=base, expected_match=0)
++ compare_images(bsync3, fmirror3, baseimg=bsync2)
++ compare_images(img_path, fmirror3)
++ log('')
++
++def test_mirror_api():
++ """
++ Test malformed and prohibited invocations of the mirror API.
++ """
++ with iotests.FilePaths(['img', 'bsync1']) as \
++ (img_path, mirror_path), \
++ iotests.VM() as vm:
++
++ log("\n=== API failure tests ===\n")
++ log('--- Preparing image & VM ---\n')
++ drive0 = Drive(img_path, vm=vm)
++ drive0.img_create(iotests.imgfmt, SIZE)
++ vm.add_device("{},id=scsi0".format(iotests.get_virtio_scsi_device()))
++ vm.launch()
++
++ file_config = {
++ 'driver': 'file',
++ 'filename': drive0.path
++ }
++
++ drive0.node = 'drive0'
++ vm.qmp_log('blockdev-add',
++ filters=[iotests.filter_qmp_testfiles],
++ node_name=drive0.node,
++ driver=drive0.fmt,
++ file=file_config)
++ log('')
++
++ target0 = Drive(mirror_path, vm=vm)
++ target0.create_target("mirror_target", drive0.fmt, drive0.size)
++ log('')
++
++ vm.qmp_log("block-dirty-bitmap-add", node=drive0.node,
++ name="bitmap0", granularity=GRANULARITY)
++ log('')
++
++ log('-- Testing invalid QMP commands --\n')
++
++ error_cases = {
++ 'incremental': {
++ None: ['on-success', 'always', 'never', None],
++ 'bitmap404': ['on-success', 'always', 'never', None],
++ 'bitmap0': ['always', 'never']
++ },
++ 'bitmap': {
++ None: ['on-success', 'always', 'never', None],
++ 'bitmap404': ['on-success', 'always', 'never', None],
++ 'bitmap0': [None],
++ },
++ 'full': {
++ None: ['on-success', 'always', 'never'],
++ 'bitmap404': ['on-success', 'always', 'never', None],
++ 'bitmap0': ['on-success', 'always', 'never', None],
++ },
++ 'top': {
++ None: ['on-success', 'always', 'never'],
++ 'bitmap404': ['on-success', 'always', 'never', None],
++ 'bitmap0': ['on-success', 'always', 'never', None],
++ },
++ 'none': {
++ None: ['on-success', 'always', 'never'],
++ 'bitmap404': ['on-success', 'always', 'never', None],
++ 'bitmap0': ['on-success', 'always', 'never', None],
++ }
++ }
++
++ # Dicts, as always, are not stably-ordered prior to 3.7, so use tuples:
++ for sync_mode in ('incremental', 'bitmap', 'full', 'top', 'none'):
++ log("-- Sync mode {:s} tests --\n".format(sync_mode))
++ for bitmap in (None, 'bitmap404', 'bitmap0'):
++ for policy in error_cases[sync_mode][bitmap]:
++ blockdev_mirror(drive0.vm, drive0.node, "mirror_target",
++ sync_mode, job_id='api_job',
++ bitmap=bitmap, bitmap_mode=policy)
++ log('')
++
++
++def main():
++ for bsync_mode in ("never", "on-success", "always"):
++ for failure in ("simulated", "intermediate", None):
++ test_bitmap_sync(bsync_mode, "bitmap", failure)
++
++# for sync_mode in ('full', 'top'):
++# for bsync_mode in ('on-success', 'always'):
++# for failure in ('simulated', 'intermediate', None):
++# test_bitmap_sync(bsync_mode, sync_mode, failure)
++
++ test_mirror_api()
++
++if __name__ == '__main__':
++ iotests.script_main(main, supported_fmts=['qcow2'],
++ supported_protocols=['file'])
+diff --git a/tests/qemu-iotests/384.out b/tests/qemu-iotests/384.out
+new file mode 100644
+index 0000000000..9b7408b6d6
+--- /dev/null
++++ b/tests/qemu-iotests/384.out
+@@ -0,0 +1,2846 @@
++
++=== Mode bitmap; Bitmap Sync never with simulated failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-cancel", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 262144,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 655360,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 983040,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 15 dirty sectors; have 15. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 983040,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 15 dirty sectors; have 15. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync never with intermediate failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "blkdebug", "image": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "inject-error": [{"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 3}, {"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 4}], "set-state": [{"event": "flush_to_disk", "new-state": 2, "state": 1}, {"event": "read_aio", "new-state": 3, "state": 2}, {"event": "read_aio", "new-state": 4, "state": 3}]}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++{"return": ""}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "error": "Input/output error", "len": 393216, "offset": 65536, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 262144,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 655360,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 983040,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 15 dirty sectors; have 15. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 983040,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 15 dirty sectors; have 15. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync never without failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 262144,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 655360,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 983040,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 15 dirty sectors; have 15. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 983040,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 15 dirty sectors; have 15. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync on-success with simulated failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-cancel", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 262144,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 655360,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 524288,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 8 dirty sectors; have 8. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync on-success with intermediate failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "blkdebug", "image": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "inject-error": [{"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 3}, {"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 4}], "set-state": [{"event": "flush_to_disk", "new-state": 2, "state": 1}, {"event": "read_aio", "new-state": 3, "state": 2}, {"event": "read_aio", "new-state": 4, "state": 3}]}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++{"return": ""}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "error": "Input/output error", "len": 393216, "offset": 65536, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 262144,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 655360,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 10 dirty sectors; have 10. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 524288,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 8 dirty sectors; have 8. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync on-success without failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 458752,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 458752,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 7 dirty sectors; have 7. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 524288,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 8 dirty sectors; have 8. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync always with simulated failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-cancel", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 458752,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 458752,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 7 dirty sectors; have 7. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 524288,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 8 dirty sectors; have 8. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync always with intermediate failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "blkdebug", "image": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "inject-error": [{"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 3}, {"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 4}], "set-state": [{"event": "flush_to_disk", "new-state": 2, "state": 1}, {"event": "read_aio", "new-state": 3, "state": 2}, {"event": "read_aio", "new-state": 4, "state": 3}]}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++{"return": ""}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "error": "Input/output error", "len": 393216, "offset": 65536, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 327680,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 5 dirty sectors; have 5. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 262144,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 589824,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 9 dirty sectors; have 9. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 524288,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 8 dirty sectors; have 8. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== Mode bitmap; Bitmap Sync always without failure ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
++{"return": {}}
++
++--- Write #0 ---
++
++write -P0x49 0x0000000 0x10000
++{"return": ""}
++write -P0x6c 0x0100000 0x10000
++{"return": ""}
++write -P0x6f 0x2000000 0x10000
++{"return": ""}
++write -P0x76 0x3ff0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {}
++}
++
++--- Reference mirror #0 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Add Bitmap ---
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++--- Write #1 ---
++
++write -P0x65 0x0000000 0x10000
++{"return": ""}
++write -P0x77 0x00f8000 0x10000
++{"return": ""}
++write -P0x72 0x2008000 0x10000
++{"return": ""}
++write -P0x69 0x3fe0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 393216,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 6 dirty sectors; have 6. OK!
++
++--- Reference mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #1 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_1"}}
++{"return": {}}
++{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Reference mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #2 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
++{"return": {}}
++--- Write #2 ---
++
++write -P0x74 0x0010000 0x10000
++{"return": ""}
++write -P0x69 0x00e8000 0x10000
++{"return": ""}
++write -P0x6e 0x2018000 0x10000
++{"return": ""}
++write -P0x67 0x3fe0000 0x20000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 458752,
++ "granularity": 65536,
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ },
++ {
++ "busy": true,
++ "count": 458752,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "locked"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 7 dirty sectors; have 7. OK!
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Write #3 ---
++
++write -P0xaa 0x0010000 0x30000
++{"return": ""}
++write -P0xbb 0x00d8000 0x10000
++{"return": ""}
++write -P0xcc 0x2028000 0x10000
++{"return": ""}
++write -P0xdd 0x3fc0000 0x10000
++{"return": ""}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 524288,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 8 dirty sectors; have 8. OK!
++
++--- Reference mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
++{"return": {}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
++--- Test mirror #3 ---
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
++{"return": {}}
++{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
++{"return": {}}
++{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{
++ "bitmaps": {
++ "drive0": [
++ {
++ "busy": false,
++ "count": 0,
++ "granularity": 65536,
++ "name": "bitmap0",
++ "persistent": false,
++ "recording": true,
++ "status": "active"
++ }
++ ]
++ }
++}
++
++= Checking Bitmap bitmap0 =
++expecting 0 dirty sectors; have 0. OK!
++
++--- Cleanup ---
++
++{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++{
++ "bitmaps": {}
++}
++
++--- Verification ---
++
++qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
++qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
++
++
++=== API failure tests ===
++
++--- Preparing image & VM ---
++
++{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
++{"return": {}}
++
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
++{"return": {}}
++{}
++{}
++{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
++{"return": {}}
++{}
++
++{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
++{"return": {}}
++
++-- Testing invalid QMP commands --
++
++-- Sync mode incremental tests --
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
++
++-- Sync mode bitmap tests --
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++-- Sync mode full tests --
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++-- Sync mode top tests --
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++-- Sync mode none tests --
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
++
++{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
++{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++
+diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
+index 025ed5238d..bee527c012 100644
+--- a/tests/qemu-iotests/group
++++ b/tests/qemu-iotests/group
+@@ -270,6 +270,7 @@
+ 253 rw quick
+ 254 rw backing quick
+ 255 rw quick
++384 rw
+ 256 rw auto quick
+ 257 rw
+ 258 rw quick
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
-Date: Mon, 6 Apr 2020 12:17:06 +0200
-Subject: [PATCH] mirror: switch to bdrv_dirty_bitmap_merge_internal
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-since sync_bitmap is busy at the point of merging, and we checked access
-beforehand.
-
-Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
----
- block/mirror.c | 8 ++++----
- 1 file changed, 4 insertions(+), 4 deletions(-)
-
-diff --git a/block/mirror.c b/block/mirror.c
-index 7d3c3252f3..fb12ccb932 100644
---- a/block/mirror.c
-+++ b/block/mirror.c
-@@ -756,8 +756,8 @@ static int mirror_exit_common(Job *job)
- job->ret == 0 && ret == 0)) {
- /* Success; synchronize copy back to sync. */
- bdrv_clear_dirty_bitmap(s->sync_bitmap, NULL);
-- bdrv_merge_dirty_bitmap(s->sync_bitmap, s->dirty_bitmap,
-- NULL, &error_abort);
-+ bdrv_dirty_bitmap_merge_internal(s->sync_bitmap, s->dirty_bitmap,
-+ NULL, true);
- }
- }
- bdrv_release_dirty_bitmap(s->dirty_bitmap);
-@@ -1754,8 +1754,8 @@ static BlockJob *mirror_start_job(
- }
-
- if (s->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
-- bdrv_merge_dirty_bitmap(s->dirty_bitmap, s->sync_bitmap,
-- NULL, &local_err);
-+ bdrv_dirty_bitmap_merge_internal(s->dirty_bitmap, s->sync_bitmap,
-+ NULL, true);
- if (local_err) {
- goto fail;
- }
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
-Date: Mon, 6 Apr 2020 12:17:07 +0200
-Subject: [PATCH] iotests: add test for bitmap mirror
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-heavily based on/practically forked off iotest 257 for bitmap backups,
-but:
-
-- no writes to filter node 'mirror-top' between completion and
-finalization, as those seem to deadlock?
-- no inclusion of not-yet-available full/top sync modes in combination
-with bitmaps
-- extra set of reference/test mirrors to verify that writes in parallel
-with active mirror work
-
-intentionally keeping copyright and ownership of original test case to
-honor provenance.
-
-Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
----
- tests/qemu-iotests/384 | 547 +++++++
- tests/qemu-iotests/384.out | 2846 ++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/group | 1 +
- 3 files changed, 3394 insertions(+)
- create mode 100755 tests/qemu-iotests/384
- create mode 100644 tests/qemu-iotests/384.out
-
-diff --git a/tests/qemu-iotests/384 b/tests/qemu-iotests/384
-new file mode 100755
-index 0000000000..b04a8e651a
---- /dev/null
-+++ b/tests/qemu-iotests/384
-@@ -0,0 +1,547 @@
-+#!/usr/bin/env python3
-+#
-+# Test bitmap-sync mirrors (incremental, differential, and partials)
-+#
-+# Copyright (c) 2019 John Snow for Red Hat, Inc.
-+#
-+# This program is free software; you can redistribute it and/or modify
-+# it under the terms of the GNU General Public License as published by
-+# the Free Software Foundation; either version 2 of the License, or
-+# (at your option) any later version.
-+#
-+# This program 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 General Public License for more details.
-+#
-+# You should have received a copy of the GNU General Public License
-+# along with this program. If not, see <http://www.gnu.org/licenses/>.
-+#
-+# owner=jsnow@redhat.com
-+
-+import math
-+import os
-+
-+import iotests
-+from iotests import log, qemu_img
-+
-+SIZE = 64 * 1024 * 1024
-+GRANULARITY = 64 * 1024
-+
-+
-+class Pattern:
-+ def __init__(self, byte, offset, size=GRANULARITY):
-+ self.byte = byte
-+ self.offset = offset
-+ self.size = size
-+
-+ def bits(self, granularity):
-+ lower = self.offset // granularity
-+ upper = (self.offset + self.size - 1) // granularity
-+ return set(range(lower, upper + 1))
-+
-+
-+class PatternGroup:
-+ """Grouping of Pattern objects. Initialize with an iterable of Patterns."""
-+ def __init__(self, patterns):
-+ self.patterns = patterns
-+
-+ def bits(self, granularity):
-+ """Calculate the unique bits dirtied by this pattern grouping"""
-+ res = set()
-+ for pattern in self.patterns:
-+ res |= pattern.bits(granularity)
-+ return res
-+
-+
-+GROUPS = [
-+ PatternGroup([
-+ # Batch 0: 4 clusters
-+ Pattern('0x49', 0x0000000),
-+ Pattern('0x6c', 0x0100000), # 1M
-+ Pattern('0x6f', 0x2000000), # 32M
-+ Pattern('0x76', 0x3ff0000)]), # 64M - 64K
-+ PatternGroup([
-+ # Batch 1: 6 clusters (3 new)
-+ Pattern('0x65', 0x0000000), # Full overwrite
-+ Pattern('0x77', 0x00f8000), # Partial-left (1M-32K)
-+ Pattern('0x72', 0x2008000), # Partial-right (32M+32K)
-+ Pattern('0x69', 0x3fe0000)]), # Adjacent-left (64M - 128K)
-+ PatternGroup([
-+ # Batch 2: 7 clusters (3 new)
-+ Pattern('0x74', 0x0010000), # Adjacent-right
-+ Pattern('0x69', 0x00e8000), # Partial-left (1M-96K)
-+ Pattern('0x6e', 0x2018000), # Partial-right (32M+96K)
-+ Pattern('0x67', 0x3fe0000,
-+ 2*GRANULARITY)]), # Overwrite [(64M-128K)-64M)
-+ PatternGroup([
-+ # Batch 3: 8 clusters (5 new)
-+ # Carefully chosen such that nothing re-dirties the one cluster
-+ # that copies out successfully before failure in Group #1.
-+ Pattern('0xaa', 0x0010000,
-+ 3*GRANULARITY), # Overwrite and 2x Adjacent-right
-+ Pattern('0xbb', 0x00d8000), # Partial-left (1M-160K)
-+ Pattern('0xcc', 0x2028000), # Partial-right (32M+160K)
-+ Pattern('0xdd', 0x3fc0000)]), # New; leaving a gap to the right
-+]
-+
-+
-+class EmulatedBitmap:
-+ def __init__(self, granularity=GRANULARITY):
-+ self._bits = set()
-+ self.granularity = granularity
-+
-+ def dirty_bits(self, bits):
-+ self._bits |= set(bits)
-+
-+ def dirty_group(self, n):
-+ self.dirty_bits(GROUPS[n].bits(self.granularity))
-+
-+ def clear(self):
-+ self._bits = set()
-+
-+ def clear_bits(self, bits):
-+ self._bits -= set(bits)
-+
-+ def clear_bit(self, bit):
-+ self.clear_bits({bit})
-+
-+ def clear_group(self, n):
-+ self.clear_bits(GROUPS[n].bits(self.granularity))
-+
-+ @property
-+ def first_bit(self):
-+ return sorted(self.bits)[0]
-+
-+ @property
-+ def bits(self):
-+ return self._bits
-+
-+ @property
-+ def count(self):
-+ return len(self.bits)
-+
-+ def compare(self, qmp_bitmap):
-+ """
-+ Print a nice human-readable message checking that a bitmap as reported
-+ by the QMP interface has as many bits set as we expect it to.
-+ """
-+
-+ name = qmp_bitmap.get('name', '(anonymous)')
-+ log("= Checking Bitmap {:s} =".format(name))
-+
-+ want = self.count
-+ have = qmp_bitmap['count'] // qmp_bitmap['granularity']
-+
-+ log("expecting {:d} dirty sectors; have {:d}. {:s}".format(
-+ want, have, "OK!" if want == have else "ERROR!"))
-+ log('')
-+
-+
-+class Drive:
-+ """Represents, vaguely, a drive attached to a VM.
-+ Includes format, graph, and device information."""
-+
-+ def __init__(self, path, vm=None):
-+ self.path = path
-+ self.vm = vm
-+ self.fmt = None
-+ self.size = None
-+ self.node = None
-+
-+ def img_create(self, fmt, size):
-+ self.fmt = fmt
-+ self.size = size
-+ iotests.qemu_img_create('-f', self.fmt, self.path, str(self.size))
-+
-+ def create_target(self, name, fmt, size):
-+ basename = os.path.basename(self.path)
-+ file_node_name = "file_{}".format(basename)
-+ vm = self.vm
-+
-+ log(vm.command('blockdev-create', job_id='bdc-file-job',
-+ options={
-+ 'driver': 'file',
-+ 'filename': self.path,
-+ 'size': 0,
-+ }))
-+ vm.run_job('bdc-file-job')
-+ log(vm.command('blockdev-add', driver='file',
-+ node_name=file_node_name, filename=self.path))
-+
-+ log(vm.command('blockdev-create', job_id='bdc-fmt-job',
-+ options={
-+ 'driver': fmt,
-+ 'file': file_node_name,
-+ 'size': size,
-+ }))
-+ vm.run_job('bdc-fmt-job')
-+ log(vm.command('blockdev-add', driver=fmt,
-+ node_name=name,
-+ file=file_node_name))
-+ self.fmt = fmt
-+ self.size = size
-+ self.node = name
-+
-+def blockdev_mirror(vm, device, target, sync, **kwargs):
-+ # Strip any arguments explicitly nulled by the caller:
-+ kwargs = {key: val for key, val in kwargs.items() if val is not None}
-+ result = vm.qmp_log('blockdev-mirror',
-+ device=device,
-+ target=target,
-+ sync=sync,
-+ filter_node_name='mirror-top',
-+ **kwargs)
-+ return result
-+
-+def blockdev_mirror_mktarget(drive, target_id, filepath, sync, **kwargs):
-+ target_drive = Drive(filepath, vm=drive.vm)
-+ target_drive.create_target(target_id, drive.fmt, drive.size)
-+ blockdev_mirror(drive.vm, drive.node, target_id, sync, **kwargs)
-+
-+def reference_mirror(drive, n, filepath):
-+ log("--- Reference mirror #{:d} ---\n".format(n))
-+ target_id = "ref_target_{:d}".format(n)
-+ job_id = "ref_mirror_{:d}".format(n)
-+ blockdev_mirror_mktarget(drive, target_id, filepath, "full",
-+ job_id=job_id)
-+ drive.vm.run_job(job_id, auto_dismiss=True)
-+ log('')
-+
-+def mirror(drive, n, filepath, sync, **kwargs):
-+ log("--- Test mirror #{:d} ---\n".format(n))
-+ target_id = "mirror_target_{:d}".format(n)
-+ job_id = "mirror_{:d}".format(n)
-+ kwargs.setdefault('auto-finalize', False)
-+ blockdev_mirror_mktarget(drive, target_id, filepath, sync,
-+ job_id=job_id, **kwargs)
-+ return job_id
-+
-+def perform_writes(drive, n, filter_node_name=None):
-+ log("--- Write #{:d} ---\n".format(n))
-+ for pattern in GROUPS[n].patterns:
-+ cmd = "write -P{:s} 0x{:07x} 0x{:x}".format(
-+ pattern.byte,
-+ pattern.offset,
-+ pattern.size)
-+ log(cmd)
-+ log(drive.vm.hmp_qemu_io(filter_node_name or drive.node, cmd))
-+ bitmaps = drive.vm.query_bitmaps()
-+ log({'bitmaps': bitmaps}, indent=2)
-+ log('')
-+ return bitmaps
-+
-+
-+def compare_images(image, reference, baseimg=None, expected_match=True):
-+ """
-+ Print a nice human-readable message comparing these images.
-+ """
-+ expected_ret = 0 if expected_match else 1
-+ if baseimg:
-+ assert qemu_img("rebase", "-u", "-b", baseimg, image) == 0
-+ ret = qemu_img("compare", image, reference)
-+ log('qemu_img compare "{:s}" "{:s}" ==> {:s}, {:s}'.format(
-+ image, reference,
-+ "Identical" if ret == 0 else "Mismatch",
-+ "OK!" if ret == expected_ret else "ERROR!"),
-+ filters=[iotests.filter_testfiles])
-+
-+def test_bitmap_sync(bsync_mode, msync_mode='bitmap', failure=None):
-+ """
-+ Test bitmap mirror routines.
-+
-+ :param bsync_mode: Is the Bitmap Sync mode, and can be any of:
-+ - on-success: This is the "incremental" style mode. Bitmaps are
-+ synchronized to what was copied out only on success.
-+ (Partial images must be discarded.)
-+ - never: This is the "differential" style mode.
-+ Bitmaps are never synchronized.
-+ - always: This is a "best effort" style mode.
-+ Bitmaps are always synchronized, regardless of failure.
-+ (Partial images must be kept.)
-+
-+ :param msync_mode: The mirror sync mode to use for the first mirror.
-+ Can be any one of:
-+ - bitmap: mirrors based on bitmap manifest.
-+ - full: Full mirrors.
-+ - top: Full mirrors of the top layer only.
-+
-+ :param failure: Is the (optional) failure mode, and can be any of:
-+ - None: No failure. Test the normative path. Default.
-+ - simulated: Cancel the job right before it completes.
-+ This also tests writes "during" the job.
-+ - intermediate: This tests a job that fails mid-process and produces
-+ an incomplete mirror. Testing limitations prevent
-+ testing competing writes.
-+ """
-+ with iotests.FilePaths(['img', 'bsync1', 'bsync2', 'bsync3',
-+ 'fmirror0', 'fmirror1', 'fmirror2', 'fmirror3']) as \
-+ (img_path, bsync1, bsync2, bsync3,
-+ fmirror0, fmirror1, fmirror2, fmirror3), \
-+ iotests.VM() as vm:
-+
-+ mode = "Mode {:s}; Bitmap Sync {:s}".format(msync_mode, bsync_mode)
-+ preposition = "with" if failure else "without"
-+ cond = "{:s} {:s}".format(preposition,
-+ "{:s} failure".format(failure) if failure
-+ else "failure")
-+ log("\n=== {:s} {:s} ===\n".format(mode, cond))
-+
-+ log('--- Preparing image & VM ---\n')
-+ drive0 = Drive(img_path, vm=vm)
-+ drive0.img_create(iotests.imgfmt, SIZE)
-+ vm.add_device("{},id=scsi0".format(iotests.get_virtio_scsi_device()))
-+ vm.launch()
-+
-+ file_config = {
-+ 'driver': 'file',
-+ 'filename': drive0.path
-+ }
-+
-+ if failure == 'intermediate':
-+ file_config = {
-+ 'driver': 'blkdebug',
-+ 'image': file_config,
-+ 'set-state': [{
-+ 'event': 'flush_to_disk',
-+ 'state': 1,
-+ 'new_state': 2
-+ }, {
-+ 'event': 'read_aio',
-+ 'state': 2,
-+ 'new_state': 3
-+ }, {
-+ 'event': 'read_aio',
-+ 'state': 3,
-+ 'new_state': 4
-+ }],
-+ 'inject-error': [{
-+ 'event': 'read_aio',
-+ 'errno': 5,
-+ 'state': 3,
-+ 'immediately': False,
-+ 'once': True
-+ }, {
-+ 'event': 'read_aio',
-+ 'errno': 5,
-+ 'state': 4,
-+ 'immediately': False,
-+ 'once': True
-+ }]
-+ }
-+
-+ drive0.node = 'drive0'
-+ vm.qmp_log('blockdev-add',
-+ filters=[iotests.filter_qmp_testfiles],
-+ node_name=drive0.node,
-+ driver=drive0.fmt,
-+ file=file_config)
-+ log('')
-+
-+ # 0 - Writes and Reference mirror
-+ perform_writes(drive0, 0)
-+ reference_mirror(drive0, 0, fmirror0)
-+ log('--- Add Bitmap ---\n')
-+ vm.qmp_log("block-dirty-bitmap-add", node=drive0.node,
-+ name="bitmap0", granularity=GRANULARITY)
-+ log('')
-+ ebitmap = EmulatedBitmap()
-+
-+ # 1 - Writes and Reference mirror
-+ bitmaps = perform_writes(drive0, 1)
-+ ebitmap.dirty_group(1)
-+ bitmap = vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps)
-+ ebitmap.compare(bitmap)
-+ reference_mirror(drive0, 1, fmirror1)
-+
-+ # 1 - Test mirror (w/ Optional induced failure)
-+ if failure == 'intermediate':
-+ # Activate blkdebug induced failure for second-to-next read
-+ log(vm.hmp_qemu_io(drive0.node, 'flush'))
-+ log('')
-+ job = mirror(drive0, 1, bsync1, msync_mode,
-+ bitmap="bitmap0", bitmap_mode=bsync_mode)
-+
-+ vm.run_job(job, auto_dismiss=True, auto_finalize=False,
-+ cancel=(failure == 'simulated'))
-+ bitmaps = vm.query_bitmaps()
-+ log({'bitmaps': bitmaps}, indent=2)
-+ log('')
-+
-+ if bsync_mode == 'always':
-+ if failure == 'intermediate':
-+ # We manage to copy one sector (one bit) before the error.
-+ ebitmap.clear_bit(ebitmap.first_bit)
-+ else:
-+ # successful mirror / cancelled complete mirror
-+ ebitmap.clear()
-+
-+ if bsync_mode == 'on-success' and not failure:
-+ ebitmap.clear()
-+
-+ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
-+
-+ # 2 - Reference mirror
-+ reference_mirror(drive0, 2, fmirror2)
-+
-+ # 2 - Bitmap mirror with writes before completion
-+ job = mirror(drive0, 2, bsync2, "bitmap",
-+ bitmap="bitmap0", bitmap_mode=bsync_mode)
-+
-+ bitmaps = perform_writes(drive0, 2)
-+ ebitmap.dirty_group(2)
-+ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
-+
-+ # don't use run_job as that logs too much even with use_log=False
-+ events = [('JOB_STATUS_CHANGE', {'data': {'id': job}})]
-+ while True:
-+ ev = iotests.filter_qmp_event(vm.events_wait(events, timeout=10))
-+ status = ev['data']['status']
-+ if status == 'ready':
-+ vm.qmp('job-complete', id=job)
-+ elif status == 'standby':
-+ vm.qmp('job-resume', id=job)
-+ elif status == 'pending':
-+ vm.qmp('job-finalize', id=job)
-+ elif status == 'null':
-+ break
-+
-+ if bsync_mode != 'never':
-+ ebitmap.clear()
-+
-+ bitmaps = vm.query_bitmaps()
-+ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
-+
-+ # 3 - Writes and Reference mirror
-+ bitmaps = perform_writes(drive0, 3)
-+ ebitmap.dirty_group(3)
-+ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
-+ reference_mirror(drive0, 3, fmirror3)
-+
-+ # 3 - Bitmap mirror (In failure modes, this is a recovery.)
-+ job = mirror(drive0, 3, bsync3, "bitmap",
-+ bitmap="bitmap0", bitmap_mode=bsync_mode)
-+
-+ vm.run_job(job, auto_dismiss=True, auto_finalize=False)
-+ bitmaps = vm.query_bitmaps()
-+
-+ log({'bitmaps': bitmaps}, indent=2)
-+ log('')
-+ if bsync_mode != 'never':
-+ ebitmap.clear()
-+ ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
-+
-+ log('--- Cleanup ---\n')
-+ vm.qmp_log("block-dirty-bitmap-remove",
-+ node=drive0.node, name="bitmap0")
-+ bitmaps = vm.query_bitmaps()
-+ log({'bitmaps': bitmaps}, indent=2)
-+ vm.shutdown()
-+ log('')
-+
-+ log('--- Verification ---\n')
-+ compare_images(bsync1, fmirror1, baseimg=fmirror0,
-+ expected_match=failure != 'intermediate')
-+ if not failure or bsync_mode == 'always':
-+ # Always keep the last mirror on success or when using 'always'
-+ base = bsync1
-+ else:
-+ base = fmirror1
-+
-+ compare_images(bsync2, fmirror2, baseimg=base, expected_match=0)
-+ compare_images(bsync3, fmirror3, baseimg=bsync2)
-+ compare_images(img_path, fmirror3)
-+ log('')
-+
-+def test_mirror_api():
-+ """
-+ Test malformed and prohibited invocations of the mirror API.
-+ """
-+ with iotests.FilePaths(['img', 'bsync1']) as \
-+ (img_path, mirror_path), \
-+ iotests.VM() as vm:
-+
-+ log("\n=== API failure tests ===\n")
-+ log('--- Preparing image & VM ---\n')
-+ drive0 = Drive(img_path, vm=vm)
-+ drive0.img_create(iotests.imgfmt, SIZE)
-+ vm.add_device("{},id=scsi0".format(iotests.get_virtio_scsi_device()))
-+ vm.launch()
-+
-+ file_config = {
-+ 'driver': 'file',
-+ 'filename': drive0.path
-+ }
-+
-+ drive0.node = 'drive0'
-+ vm.qmp_log('blockdev-add',
-+ filters=[iotests.filter_qmp_testfiles],
-+ node_name=drive0.node,
-+ driver=drive0.fmt,
-+ file=file_config)
-+ log('')
-+
-+ target0 = Drive(mirror_path, vm=vm)
-+ target0.create_target("mirror_target", drive0.fmt, drive0.size)
-+ log('')
-+
-+ vm.qmp_log("block-dirty-bitmap-add", node=drive0.node,
-+ name="bitmap0", granularity=GRANULARITY)
-+ log('')
-+
-+ log('-- Testing invalid QMP commands --\n')
-+
-+ error_cases = {
-+ 'incremental': {
-+ None: ['on-success', 'always', 'never', None],
-+ 'bitmap404': ['on-success', 'always', 'never', None],
-+ 'bitmap0': ['always', 'never']
-+ },
-+ 'bitmap': {
-+ None: ['on-success', 'always', 'never', None],
-+ 'bitmap404': ['on-success', 'always', 'never', None],
-+ 'bitmap0': [None],
-+ },
-+ 'full': {
-+ None: ['on-success', 'always', 'never'],
-+ 'bitmap404': ['on-success', 'always', 'never', None],
-+ 'bitmap0': ['on-success', 'always', 'never', None],
-+ },
-+ 'top': {
-+ None: ['on-success', 'always', 'never'],
-+ 'bitmap404': ['on-success', 'always', 'never', None],
-+ 'bitmap0': ['on-success', 'always', 'never', None],
-+ },
-+ 'none': {
-+ None: ['on-success', 'always', 'never'],
-+ 'bitmap404': ['on-success', 'always', 'never', None],
-+ 'bitmap0': ['on-success', 'always', 'never', None],
-+ }
-+ }
-+
-+ # Dicts, as always, are not stably-ordered prior to 3.7, so use tuples:
-+ for sync_mode in ('incremental', 'bitmap', 'full', 'top', 'none'):
-+ log("-- Sync mode {:s} tests --\n".format(sync_mode))
-+ for bitmap in (None, 'bitmap404', 'bitmap0'):
-+ for policy in error_cases[sync_mode][bitmap]:
-+ blockdev_mirror(drive0.vm, drive0.node, "mirror_target",
-+ sync_mode, job_id='api_job',
-+ bitmap=bitmap, bitmap_mode=policy)
-+ log('')
-+
-+
-+def main():
-+ for bsync_mode in ("never", "on-success", "always"):
-+ for failure in ("simulated", "intermediate", None):
-+ test_bitmap_sync(bsync_mode, "bitmap", failure)
-+
-+# for sync_mode in ('full', 'top'):
-+# for bsync_mode in ('on-success', 'always'):
-+# for failure in ('simulated', 'intermediate', None):
-+# test_bitmap_sync(bsync_mode, sync_mode, failure)
-+
-+ test_mirror_api()
-+
-+if __name__ == '__main__':
-+ iotests.script_main(main, supported_fmts=['qcow2'],
-+ supported_protocols=['file'])
-diff --git a/tests/qemu-iotests/384.out b/tests/qemu-iotests/384.out
-new file mode 100644
-index 0000000000..9b7408b6d6
---- /dev/null
-+++ b/tests/qemu-iotests/384.out
-@@ -0,0 +1,2846 @@
-+
-+=== Mode bitmap; Bitmap Sync never with simulated failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-cancel", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 262144,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 655360,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 983040,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 15 dirty sectors; have 15. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 983040,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 15 dirty sectors; have 15. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync never with intermediate failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "blkdebug", "image": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "inject-error": [{"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 3}, {"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 4}], "set-state": [{"event": "flush_to_disk", "new-state": 2, "state": 1}, {"event": "read_aio", "new-state": 3, "state": 2}, {"event": "read_aio", "new-state": 4, "state": 3}]}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+{"return": ""}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "error": "Input/output error", "len": 393216, "offset": 65536, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 262144,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 655360,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 983040,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 15 dirty sectors; have 15. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 983040,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 15 dirty sectors; have 15. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync never without failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 262144,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 655360,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 983040,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 15 dirty sectors; have 15. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 983040, "offset": 983040, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 983040,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 15 dirty sectors; have 15. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync on-success with simulated failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-cancel", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 262144,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 655360,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 524288,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 8 dirty sectors; have 8. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync on-success with intermediate failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "blkdebug", "image": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "inject-error": [{"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 3}, {"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 4}], "set-state": [{"event": "flush_to_disk", "new-state": 2, "state": 1}, {"event": "read_aio", "new-state": 3, "state": 2}, {"event": "read_aio", "new-state": 4, "state": 3}]}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+{"return": ""}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "error": "Input/output error", "len": 393216, "offset": 65536, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 262144,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 655360,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 10 dirty sectors; have 10. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 524288,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 8 dirty sectors; have 8. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync on-success without failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 458752,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 458752,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 7 dirty sectors; have 7. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 524288,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 8 dirty sectors; have 8. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync always with simulated failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-cancel", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 458752,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 458752,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 7 dirty sectors; have 7. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 524288,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 8 dirty sectors; have 8. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync always with intermediate failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "blkdebug", "image": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "inject-error": [{"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 3}, {"errno": 5, "event": "read_aio", "immediately": false, "once": true, "state": 4}], "set-state": [{"event": "flush_to_disk", "new-state": 2, "state": 1}, {"event": "read_aio", "new-state": 3, "state": 2}, {"event": "read_aio", "new-state": 4, "state": 3}]}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+{"return": ""}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"action": "report", "device": "mirror_1", "operation": "read"}, "event": "BLOCK_JOB_ERROR", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "error": "Input/output error", "len": 393216, "offset": 65536, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 327680,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 5 dirty sectors; have 5. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 262144,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 589824,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 9 dirty sectors; have 9. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 524288,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 8 dirty sectors; have 8. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== Mode bitmap; Bitmap Sync always without failure ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+--- Write #0 ---
-+
-+write -P0x49 0x0000000 0x10000
-+{"return": ""}
-+write -P0x6c 0x0100000 0x10000
-+{"return": ""}
-+write -P0x6f 0x2000000 0x10000
-+{"return": ""}
-+write -P0x76 0x3ff0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Reference mirror #0 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_0", "sync": "full", "target": "ref_target_0"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_0"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_0", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Add Bitmap ---
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+--- Write #1 ---
-+
-+write -P0x65 0x0000000 0x10000
-+{"return": ""}
-+write -P0x77 0x00f8000 0x10000
-+{"return": ""}
-+write -P0x72 0x2008000 0x10000
-+{"return": ""}
-+write -P0x69 0x3fe0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 393216,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 6 dirty sectors; have 6. OK!
-+
-+--- Reference mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_1", "sync": "full", "target": "ref_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_1", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #1 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_1", "sync": "bitmap", "target": "mirror_target_1"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_1"}}
-+{"return": {}}
-+{"data": {"id": "mirror_1", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_1", "len": 393216, "offset": 393216, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Reference mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_2", "sync": "full", "target": "ref_target_2"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_2"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_2", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #2 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_2", "sync": "bitmap", "target": "mirror_target_2"}}
-+{"return": {}}
-+--- Write #2 ---
-+
-+write -P0x74 0x0010000 0x10000
-+{"return": ""}
-+write -P0x69 0x00e8000 0x10000
-+{"return": ""}
-+write -P0x6e 0x2018000 0x10000
-+{"return": ""}
-+write -P0x67 0x3fe0000 0x20000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 458752,
-+ "granularity": 65536,
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ },
-+ {
-+ "busy": true,
-+ "count": 458752,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "locked"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 7 dirty sectors; have 7. OK!
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Write #3 ---
-+
-+write -P0xaa 0x0010000 0x30000
-+{"return": ""}
-+write -P0xbb 0x00d8000 0x10000
-+{"return": ""}
-+write -P0xcc 0x2028000 0x10000
-+{"return": ""}
-+write -P0xdd 0x3fc0000 0x10000
-+{"return": ""}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 524288,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 8 dirty sectors; have 8. OK!
-+
-+--- Reference mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "ref_mirror_3", "sync": "full", "target": "ref_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "ref_mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "ref_mirror_3", "len": 67108864, "offset": 67108864, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+
-+--- Test mirror #3 ---
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+{"execute": "blockdev-mirror", "arguments": {"auto-finalize": false, "bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "mirror_3", "sync": "bitmap", "target": "mirror_target_3"}}
-+{"return": {}}
-+{"execute": "job-complete", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"execute": "job-finalize", "arguments": {"id": "mirror_3"}}
-+{"return": {}}
-+{"data": {"id": "mirror_3", "type": "mirror"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "mirror_3", "len": 524288, "offset": 524288, "speed": 0, "type": "mirror"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{
-+ "bitmaps": {
-+ "drive0": [
-+ {
-+ "busy": false,
-+ "count": 0,
-+ "granularity": 65536,
-+ "name": "bitmap0",
-+ "persistent": false,
-+ "recording": true,
-+ "status": "active"
-+ }
-+ ]
-+ }
-+}
-+
-+= Checking Bitmap bitmap0 =
-+expecting 0 dirty sectors; have 0. OK!
-+
-+--- Cleanup ---
-+
-+{"execute": "block-dirty-bitmap-remove", "arguments": {"name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+{
-+ "bitmaps": {}
-+}
-+
-+--- Verification ---
-+
-+qemu_img compare "TEST_DIR/PID-bsync1" "TEST_DIR/PID-fmirror1" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-bsync2" "TEST_DIR/PID-fmirror2" ==> Mismatch, OK!
-+qemu_img compare "TEST_DIR/PID-bsync3" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
-+
-+
-+=== API failure tests ===
-+
-+--- Preparing image & VM ---
-+
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": {"driver": "file", "filename": "TEST_DIR/PID-img"}, "node-name": "drive0"}}
-+{"return": {}}
-+
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-file-job"}}
-+{"return": {}}
-+{}
-+{}
-+{"execute": "job-dismiss", "arguments": {"id": "bdc-fmt-job"}}
-+{"return": {}}
-+{}
-+
-+{"execute": "block-dirty-bitmap-add", "arguments": {"granularity": 65536, "name": "bitmap0", "node": "drive0"}}
-+{"return": {}}
-+
-+-- Testing invalid QMP commands --
-+
-+-- Sync mode incremental tests --
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
-+
-+-- Sync mode bitmap tests --
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+-- Sync mode full tests --
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+-- Sync mode top tests --
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+-- Sync mode none tests --
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
-+
-+{"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
-+{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+
-diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
-index 025ed5238d..bee527c012 100644
---- a/tests/qemu-iotests/group
-+++ b/tests/qemu-iotests/group
-@@ -270,6 +270,7 @@
- 253 rw quick
- 254 rw backing quick
- 255 rw quick
-+384 rw
- 256 rw auto quick
- 257 rw
- 258 rw quick
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
+Date: Mon, 6 Apr 2020 12:17:08 +0200
+Subject: [PATCH] mirror: move some checks to qmp
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+and assert the passing conditions in block/mirror.c. while incremental
+mode was never available for drive-mirror, it makes the interface more
+uniform w.r.t. backup block jobs.
+
+Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
+---
+ block/mirror.c | 28 +++------------
+ blockdev.c | 29 +++++++++++++++
+ tests/qemu-iotests/384.out | 72 +++++++++++++++++++-------------------
+ 3 files changed, 70 insertions(+), 59 deletions(-)
+
+diff --git a/block/mirror.c b/block/mirror.c
+index fb12ccb932..dfce442e97 100644
+--- a/block/mirror.c
++++ b/block/mirror.c
+@@ -1589,31 +1589,13 @@ static BlockJob *mirror_start_job(
+ Error *local_err = NULL;
+ int ret;
+
+- if (sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
+- error_setg(errp, "Sync mode '%s' not supported",
+- MirrorSyncMode_str(sync_mode));
+- return NULL;
+- } else if (sync_mode == MIRROR_SYNC_MODE_BITMAP) {
+- if (!bitmap) {
+- error_setg(errp, "Must provide a valid bitmap name for '%s'"
+- " sync mode",
+- MirrorSyncMode_str(sync_mode));
+- return NULL;
+- }
+- } else if (bitmap) {
+- error_setg(errp,
+- "sync mode '%s' is not compatible with bitmaps",
+- MirrorSyncMode_str(sync_mode));
+- return NULL;
+- }
++ /* QMP interface protects us from these cases */
++ assert(sync_mode != MIRROR_SYNC_MODE_INCREMENTAL);
++ assert((bitmap && sync_mode == MIRROR_SYNC_MODE_BITMAP) ||
++ (!bitmap && sync_mode != MIRROR_SYNC_MODE_BITMAP));
++ assert(!(bitmap && granularity));
+
+ if (bitmap) {
+- if (granularity) {
+- error_setg(errp, "granularity (%d)"
+- "cannot be specified when a bitmap is provided",
+- granularity);
+- return NULL;
+- }
+ granularity = bdrv_dirty_bitmap_granularity(bitmap);
+
+ if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
+diff --git a/blockdev.c b/blockdev.c
+index 0d480f02c7..be87d65c02 100644
+--- a/blockdev.c
++++ b/blockdev.c
+@@ -2953,7 +2953,36 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
+ sync = MIRROR_SYNC_MODE_FULL;
+ }
+
++ if ((sync == MIRROR_SYNC_MODE_BITMAP) ||
++ (sync == MIRROR_SYNC_MODE_INCREMENTAL)) {
++ /* done before desugaring 'incremental' to print the right message */
++ if (!has_bitmap) {
++ error_setg(errp, "Must provide a valid bitmap name for "
++ "'%s' sync mode", MirrorSyncMode_str(sync));
++ return;
++ }
++ }
++
++ if (sync == MIRROR_SYNC_MODE_INCREMENTAL) {
++ if (has_bitmap_mode &&
++ bitmap_mode != BITMAP_SYNC_MODE_ON_SUCCESS) {
++ error_setg(errp, "Bitmap sync mode must be '%s' "
++ "when using sync mode '%s'",
++ BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS),
++ MirrorSyncMode_str(sync));
++ return;
++ }
++ has_bitmap_mode = true;
++ sync = MIRROR_SYNC_MODE_BITMAP;
++ bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
++ }
++
+ if (has_bitmap) {
++ if (sync != MIRROR_SYNC_MODE_BITMAP) {
++ error_setg(errp, "Sync mode '%s' not supported with bitmap.",
++ MirrorSyncMode_str(sync));
++ return;
++ }
+ if (granularity) {
+ error_setg(errp, "Granularity and bitmap cannot both be set");
+ return;
+diff --git a/tests/qemu-iotests/384.out b/tests/qemu-iotests/384.out
+index 9b7408b6d6..06a2e29058 100644
+--- a/tests/qemu-iotests/384.out
++++ b/tests/qemu-iotests/384.out
+@@ -2681,45 +2681,45 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
+ -- Sync mode incremental tests --
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+ {"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
++{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
++{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
+
+ -- Sync mode bitmap tests --
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
++{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
+ {"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
+@@ -2751,28 +2751,28 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
+ {"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ -- Sync mode top tests --
+
+@@ -2786,28 +2786,28 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
+ {"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
+
+ -- Sync mode none tests --
+
+@@ -2821,26 +2821,26 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
+ {"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
+ {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
+-{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
++{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
+
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Mon, 29 Jun 2020 11:06:03 +0200
+Subject: [PATCH] PVE-Backup: Add dirty-bitmap tracking for incremental backups
+
+Uses QEMU's existing MIRROR_SYNC_MODE_BITMAP and a dirty-bitmap on top
+of all backed-up drives. This will only execute the data-write callback
+for any changed chunks, the PBS rust code will reuse chunks from the
+previous index for everything it doesn't receive if reuse_index is true.
+
+On error or cancellation, remove all dirty bitmaps to ensure
+consistency.
+
+Add PBS/incremental specific information to query backup info QMP and
+HMP commands.
+
+Only supported for PBS backups.
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
+Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
+---
+ block/monitor/block-hmp-cmds.c | 1 +
+ monitor/hmp-cmds.c | 45 ++++++++++++----
+ proxmox-backup-client.c | 3 +-
+ proxmox-backup-client.h | 1 +
+ pve-backup.c | 95 ++++++++++++++++++++++++++++++----
+ qapi/block-core.json | 12 ++++-
+ 6 files changed, 134 insertions(+), 23 deletions(-)
+
+diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
+index d485c3ac79..fdc85a5c0e 100644
+--- a/block/monitor/block-hmp-cmds.c
++++ b/block/monitor/block-hmp-cmds.c
+@@ -1038,6 +1038,7 @@ void hmp_backup(Monitor *mon, const QDict *qdict)
+ false, NULL, // PBS fingerprint
+ false, NULL, // PBS backup-id
+ false, 0, // PBS backup-time
++ false, false, // PBS incremental
+ true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
+ false, NULL, false, NULL, !!devlist,
+ devlist, qdict_haskey(qdict, "speed"), speed, &error);
+diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
+index 0e2d166552..3ff014d32a 100644
+--- a/monitor/hmp-cmds.c
++++ b/monitor/hmp-cmds.c
+@@ -218,19 +218,42 @@ void hmp_info_backup(Monitor *mon, const QDict *qdict)
+ monitor_printf(mon, "End time: %s", ctime(&info->end_time));
+ }
+
+- int per = (info->has_total && info->total &&
+- info->has_transferred && info->transferred) ?
+- (info->transferred * 100)/info->total : 0;
+- int zero_per = (info->has_total && info->total &&
+- info->has_zero_bytes && info->zero_bytes) ?
+- (info->zero_bytes * 100)/info->total : 0;
+ monitor_printf(mon, "Backup file: %s\n", info->backup_file);
+ monitor_printf(mon, "Backup uuid: %s\n", info->uuid);
+- monitor_printf(mon, "Total size: %zd\n", info->total);
+- monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
+- info->transferred, per);
+- monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
+- info->zero_bytes, zero_per);
++
++ if (!(info->has_total && info->total)) {
++ // this should not happen normally
++ monitor_printf(mon, "Total size: %d\n", 0);
++ } else {
++ bool incremental = false;
++ size_t total_or_dirty = info->total;
++ if (info->has_transferred) {
++ if (info->has_dirty && info->dirty) {
++ if (info->dirty < info->total) {
++ total_or_dirty = info->dirty;
++ incremental = true;
++ }
++ }
++ }
++
++ int per = (info->transferred * 100)/total_or_dirty;
++
++ monitor_printf(mon, "Backup mode: %s\n", incremental ? "incremental" : "full");
++
++ int zero_per = (info->has_zero_bytes && info->zero_bytes) ?
++ (info->zero_bytes * 100)/info->total : 0;
++ monitor_printf(mon, "Total size: %zd\n", info->total);
++ monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
++ info->transferred, per);
++ monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
++ info->zero_bytes, zero_per);
++
++ if (info->has_reused) {
++ int reused_per = (info->reused * 100)/total_or_dirty;
++ monitor_printf(mon, "Reused bytes: %zd (%d%%)\n",
++ info->reused, reused_per);
++ }
++ }
+ }
+
+ qapi_free_BackupStatus(info);
+diff --git a/proxmox-backup-client.c b/proxmox-backup-client.c
+index b7bc7f2574..0e9c584701 100644
+--- a/proxmox-backup-client.c
++++ b/proxmox-backup-client.c
+@@ -95,6 +95,7 @@ proxmox_backup_co_register_image(
+ ProxmoxBackupHandle *pbs,
+ const char *device_name,
+ uint64_t size,
++ bool incremental,
+ Error **errp)
+ {
+ Coroutine *co = qemu_coroutine_self();
+@@ -104,7 +105,7 @@ proxmox_backup_co_register_image(
+ int pbs_res = -1;
+
+ proxmox_backup_register_image_async(
+- pbs, device_name, size ,proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
++ pbs, device_name, size, incremental, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
+ qemu_coroutine_yield();
+ if (pbs_res < 0) {
+ if (errp) error_setg(errp, "backup register image failed: %s", pbs_err ? pbs_err : "unknown error");
+diff --git a/proxmox-backup-client.h b/proxmox-backup-client.h
+index b311bf8de8..20fd6b1719 100644
+--- a/proxmox-backup-client.h
++++ b/proxmox-backup-client.h
+@@ -25,6 +25,7 @@ proxmox_backup_co_register_image(
+ ProxmoxBackupHandle *pbs,
+ const char *device_name,
+ uint64_t size,
++ bool incremental,
+ Error **errp);
+
+
+diff --git a/pve-backup.c b/pve-backup.c
+index d40f3f2fd6..d50f03a050 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -28,6 +28,8 @@
+ *
+ */
+
++const char *PBS_BITMAP_NAME = "pbs-incremental-dirty-bitmap";
++
+ static struct PVEBackupState {
+ struct {
+ // Everithing accessed from qmp_backup_query command is protected using lock
+@@ -39,7 +41,9 @@ static struct PVEBackupState {
+ uuid_t uuid;
+ char uuid_str[37];
+ size_t total;
++ size_t dirty;
+ size_t transferred;
++ size_t reused;
+ size_t zero_bytes;
+ } stat;
+ int64_t speed;
+@@ -66,6 +70,7 @@ typedef struct PVEBackupDevInfo {
+ uint8_t dev_id;
+ bool completed;
+ char targetfile[PATH_MAX];
++ BdrvDirtyBitmap *bitmap;
+ BlockDriverState *target;
+ } PVEBackupDevInfo;
+
+@@ -105,11 +110,12 @@ static bool pvebackup_error_or_canceled(void)
+ return error_or_canceled;
+ }
+
+-static void pvebackup_add_transfered_bytes(size_t transferred, size_t zero_bytes)
++static void pvebackup_add_transfered_bytes(size_t transferred, size_t zero_bytes, size_t reused)
+ {
+ qemu_mutex_lock(&backup_state.stat.lock);
+ backup_state.stat.zero_bytes += zero_bytes;
+ backup_state.stat.transferred += transferred;
++ backup_state.stat.reused += reused;
+ qemu_mutex_unlock(&backup_state.stat.lock);
+ }
+
+@@ -148,7 +154,8 @@ pvebackup_co_dump_pbs_cb(
+ pvebackup_propagate_error(local_err);
+ return pbs_res;
+ } else {
+- pvebackup_add_transfered_bytes(size, !buf ? size : 0);
++ size_t reused = (pbs_res == 0) ? size : 0;
++ pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
+ }
+
+ return size;
+@@ -208,11 +215,11 @@ pvebackup_co_dump_vma_cb(
+ } else {
+ if (remaining >= VMA_CLUSTER_SIZE) {
+ assert(ret == VMA_CLUSTER_SIZE);
+- pvebackup_add_transfered_bytes(VMA_CLUSTER_SIZE, zero_bytes);
++ pvebackup_add_transfered_bytes(VMA_CLUSTER_SIZE, zero_bytes, 0);
+ remaining -= VMA_CLUSTER_SIZE;
+ } else {
+ assert(ret == remaining);
+- pvebackup_add_transfered_bytes(remaining, zero_bytes);
++ pvebackup_add_transfered_bytes(remaining, zero_bytes, 0);
+ remaining = 0;
+ }
+ }
+@@ -248,6 +255,18 @@ static void coroutine_fn pvebackup_co_cleanup(void *unused)
+ if (local_err != NULL) {
+ pvebackup_propagate_error(local_err);
+ }
++ } else {
++ // on error or cancel we cannot ensure synchronization of dirty
++ // bitmaps with backup server, so remove all and do full backup next
++ GList *l = backup_state.di_list;
++ while (l) {
++ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
++ l = g_list_next(l);
++
++ if (di->bitmap) {
++ bdrv_release_dirty_bitmap(di->bitmap);
++ }
++ }
+ }
+
+ proxmox_backup_disconnect(backup_state.pbs);
+@@ -303,6 +322,12 @@ static void pvebackup_complete_cb(void *opaque, int ret)
+ // remove self from job queue
+ backup_state.di_list = g_list_remove(backup_state.di_list, di);
+
++ if (di->bitmap && ret < 0) {
++ // on error or cancel we cannot ensure synchronization of dirty
++ // bitmaps with backup server, so remove all and do full backup next
++ bdrv_release_dirty_bitmap(di->bitmap);
++ }
++
+ g_free(di);
+
+ qemu_mutex_unlock(&backup_state.backup_mutex);
+@@ -470,12 +495,18 @@ static bool create_backup_jobs(void) {
+
+ assert(di->target != NULL);
+
++ MirrorSyncMode sync_mode = MIRROR_SYNC_MODE_FULL;
++ BitmapSyncMode bitmap_mode = BITMAP_SYNC_MODE_NEVER;
++ if (di->bitmap) {
++ sync_mode = MIRROR_SYNC_MODE_BITMAP;
++ bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
++ }
+ AioContext *aio_context = bdrv_get_aio_context(di->bs);
+ aio_context_acquire(aio_context);
+
+ BlockJob *job = backup_job_create(
+- NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
+- BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
++ NULL, di->bs, di->target, backup_state.speed, sync_mode, di->bitmap,
++ bitmap_mode, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
+ JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
+
+ aio_context_release(aio_context);
+@@ -526,6 +557,8 @@ typedef struct QmpBackupTask {
+ const char *fingerprint;
+ bool has_fingerprint;
+ int64_t backup_time;
++ bool has_incremental;
++ bool incremental;
+ bool has_format;
+ BackupFormat format;
+ bool has_config_file;
+@@ -617,6 +650,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ }
+
+ size_t total = 0;
++ size_t dirty = 0;
+
+ l = di_list;
+ while (l) {
+@@ -654,6 +688,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
+ firewall_name = "fw.conf";
+
++ bool incremental = task->has_incremental && task->incremental;
++
+ char *pbs_err = NULL;
+ pbs = proxmox_backup_new(
+ task->backup_file,
+@@ -673,7 +709,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ goto err;
+ }
+
+- if (proxmox_backup_co_connect(pbs, task->errp) < 0)
++ int connect_result = proxmox_backup_co_connect(pbs, task->errp);
++ if (connect_result < 0)
+ goto err;
+
+ /* register all devices */
+@@ -684,9 +721,32 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+
+ const char *devname = bdrv_get_device_name(di->bs);
+
+- int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, task->errp);
+- if (dev_id < 0)
++ BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
++
++ bool use_incremental = false;
++ if (incremental) {
++ if (bitmap == NULL) {
++ bitmap = bdrv_create_dirty_bitmap(di->bs, dump_cb_block_size, PBS_BITMAP_NAME, task->errp);
++ if (!bitmap) {
++ goto err;
++ }
++ /* mark entire bitmap as dirty to make full backup first */
++ bdrv_set_dirty_bitmap(bitmap, 0, di->size);
++ dirty += di->size;
++ } else {
++ use_incremental = true;
++ dirty += bdrv_get_dirty_count(bitmap);
++ }
++ di->bitmap = bitmap;
++ } else if (bitmap != NULL) {
++ dirty += di->size;
++ bdrv_release_dirty_bitmap(bitmap);
++ }
++
++ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, use_incremental, task->errp);
++ if (dev_id < 0) {
+ goto err;
++ }
+
+ if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_pbs_cb, di, task->errp))) {
+ goto err;
+@@ -695,6 +755,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ di->dev_id = dev_id;
+ }
+ } else if (format == BACKUP_FORMAT_VMA) {
++ dirty = total;
++
+ vmaw = vma_writer_create(task->backup_file, uuid, &local_err);
+ if (!vmaw) {
+ if (local_err) {
+@@ -722,6 +784,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ }
+ }
+ } else if (format == BACKUP_FORMAT_DIR) {
++ dirty = total;
++
+ if (mkdir(task->backup_file, 0640) != 0) {
+ error_setg_errno(task->errp, errno, "can't create directory '%s'\n",
+ task->backup_file);
+@@ -794,8 +858,10 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ char *uuid_str = g_strdup(backup_state.stat.uuid_str);
+
+ backup_state.stat.total = total;
++ backup_state.stat.dirty = dirty;
+ backup_state.stat.transferred = 0;
+ backup_state.stat.zero_bytes = 0;
++ backup_state.stat.reused = dirty >= total ? 0 : total - dirty;
+
+ qemu_mutex_unlock(&backup_state.stat.lock);
+
+@@ -819,6 +885,10 @@ err:
+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+ l = g_list_next(l);
+
++ if (di->bitmap) {
++ bdrv_release_dirty_bitmap(di->bitmap);
++ }
++
+ if (di->target) {
+ bdrv_unref(di->target);
+ }
+@@ -860,6 +930,7 @@ UuidInfo *qmp_backup(
+ bool has_fingerprint, const char *fingerprint,
+ bool has_backup_id, const char *backup_id,
+ bool has_backup_time, int64_t backup_time,
++ bool has_incremental, bool incremental,
+ bool has_format, BackupFormat format,
+ bool has_config_file, const char *config_file,
+ bool has_firewall_file, const char *firewall_file,
+@@ -878,6 +949,8 @@ UuidInfo *qmp_backup(
+ .backup_id = backup_id,
+ .has_backup_time = has_backup_time,
+ .backup_time = backup_time,
++ .has_incremental = has_incremental,
++ .incremental = incremental,
+ .has_format = has_format,
+ .format = format,
+ .has_config_file = has_config_file,
+@@ -946,10 +1019,14 @@ BackupStatus *qmp_query_backup(Error **errp)
+
+ info->has_total = true;
+ info->total = backup_state.stat.total;
++ info->has_dirty = true;
++ info->dirty = backup_state.stat.dirty;
+ info->has_zero_bytes = true;
+ info->zero_bytes = backup_state.stat.zero_bytes;
+ info->has_transferred = true;
+ info->transferred = backup_state.stat.transferred;
++ info->has_reused = true;
++ info->reused = backup_state.stat.reused;
+
+ qemu_mutex_unlock(&backup_state.stat.lock);
+
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index 9db8e26517..6cad1e0e38 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -767,8 +767,13 @@
+ #
+ # @total: total amount of bytes involved in the backup process
+ #
++# @dirty: with incremental mode, this is the amount of bytes involved
++# in the backup process which are marked dirty.
++#
+ # @transferred: amount of bytes already backed up.
+ #
++# @reused: amount of bytes reused due to deduplication.
++#
+ # @zero-bytes: amount of 'zero' bytes detected.
+ #
+ # @start-time: time (epoch) when backup job started.
+@@ -781,8 +786,8 @@
+ #
+ ##
+ { 'struct': 'BackupStatus',
+- 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int',
+- '*transferred': 'int', '*zero-bytes': 'int',
++ 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int', '*dirty': 'int',
++ '*transferred': 'int', '*zero-bytes': 'int', '*reused': 'int',
+ '*start-time': 'int', '*end-time': 'int',
+ '*backup-file': 'str', '*uuid': 'str' } }
+
+@@ -825,6 +830,8 @@
+ #
+ # @backup-time: backup timestamp (Unix epoch, required for format 'pbs')
+ #
++# @incremental: sync incremental changes since last job (optional for format 'pbs')
++#
+ # Returns: the uuid of the backup job
+ #
+ ##
+@@ -835,6 +842,7 @@
+ '*fingerprint': 'str',
+ '*backup-id': 'str',
+ '*backup-time': 'int',
++ '*incremental': 'bool',
+ '*format': 'BackupFormat',
+ '*config-file': 'str',
+ '*firewall-file': 'str',
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
-Date: Mon, 6 Apr 2020 12:17:08 +0200
-Subject: [PATCH] mirror: move some checks to qmp
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-and assert the passing conditions in block/mirror.c. while incremental
-mode was never available for drive-mirror, it makes the interface more
-uniform w.r.t. backup block jobs.
-
-Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
----
- block/mirror.c | 28 +++------------
- blockdev.c | 29 +++++++++++++++
- tests/qemu-iotests/384.out | 72 +++++++++++++++++++-------------------
- 3 files changed, 70 insertions(+), 59 deletions(-)
-
-diff --git a/block/mirror.c b/block/mirror.c
-index fb12ccb932..dfce442e97 100644
---- a/block/mirror.c
-+++ b/block/mirror.c
-@@ -1589,31 +1589,13 @@ static BlockJob *mirror_start_job(
- Error *local_err = NULL;
- int ret;
-
-- if (sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
-- error_setg(errp, "Sync mode '%s' not supported",
-- MirrorSyncMode_str(sync_mode));
-- return NULL;
-- } else if (sync_mode == MIRROR_SYNC_MODE_BITMAP) {
-- if (!bitmap) {
-- error_setg(errp, "Must provide a valid bitmap name for '%s'"
-- " sync mode",
-- MirrorSyncMode_str(sync_mode));
-- return NULL;
-- }
-- } else if (bitmap) {
-- error_setg(errp,
-- "sync mode '%s' is not compatible with bitmaps",
-- MirrorSyncMode_str(sync_mode));
-- return NULL;
-- }
-+ /* QMP interface protects us from these cases */
-+ assert(sync_mode != MIRROR_SYNC_MODE_INCREMENTAL);
-+ assert((bitmap && sync_mode == MIRROR_SYNC_MODE_BITMAP) ||
-+ (!bitmap && sync_mode != MIRROR_SYNC_MODE_BITMAP));
-+ assert(!(bitmap && granularity));
-
- if (bitmap) {
-- if (granularity) {
-- error_setg(errp, "granularity (%d)"
-- "cannot be specified when a bitmap is provided",
-- granularity);
-- return NULL;
-- }
- granularity = bdrv_dirty_bitmap_granularity(bitmap);
-
- if (bitmap_mode != BITMAP_SYNC_MODE_NEVER) {
-diff --git a/blockdev.c b/blockdev.c
-index 4665321bd8..1db0cbcad5 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -2954,7 +2954,36 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
- sync = MIRROR_SYNC_MODE_FULL;
- }
-
-+ if ((sync == MIRROR_SYNC_MODE_BITMAP) ||
-+ (sync == MIRROR_SYNC_MODE_INCREMENTAL)) {
-+ /* done before desugaring 'incremental' to print the right message */
-+ if (!has_bitmap) {
-+ error_setg(errp, "Must provide a valid bitmap name for "
-+ "'%s' sync mode", MirrorSyncMode_str(sync));
-+ return;
-+ }
-+ }
-+
-+ if (sync == MIRROR_SYNC_MODE_INCREMENTAL) {
-+ if (has_bitmap_mode &&
-+ bitmap_mode != BITMAP_SYNC_MODE_ON_SUCCESS) {
-+ error_setg(errp, "Bitmap sync mode must be '%s' "
-+ "when using sync mode '%s'",
-+ BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS),
-+ MirrorSyncMode_str(sync));
-+ return;
-+ }
-+ has_bitmap_mode = true;
-+ sync = MIRROR_SYNC_MODE_BITMAP;
-+ bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
-+ }
-+
- if (has_bitmap) {
-+ if (sync != MIRROR_SYNC_MODE_BITMAP) {
-+ error_setg(errp, "Sync mode '%s' not supported with bitmap.",
-+ MirrorSyncMode_str(sync));
-+ return;
-+ }
- if (granularity) {
- error_setg(errp, "Granularity and bitmap cannot both be set");
- return;
-diff --git a/tests/qemu-iotests/384.out b/tests/qemu-iotests/384.out
-index 9b7408b6d6..06a2e29058 100644
---- a/tests/qemu-iotests/384.out
-+++ b/tests/qemu-iotests/384.out
-@@ -2681,45 +2681,45 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
- -- Sync mode incremental tests --
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
-
- {"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'incremental' sync mode"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
- {"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
-+{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "incremental", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Sync mode 'incremental' not supported"}}
-+{"error": {"class": "GenericError", "desc": "Bitmap sync mode must be 'on-success' when using sync mode 'incremental'"}}
-
- -- Sync mode bitmap tests --
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-+{"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
-
- {"execute": "blockdev-mirror", "arguments": {"device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "bitmap", "target": "mirror_target"}}
- {"error": {"class": "GenericError", "desc": "Must provide a valid bitmap name for 'bitmap' sync mode"}}
-@@ -2751,28 +2751,28 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
- {"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "full", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- -- Sync mode top tests --
-
-@@ -2786,28 +2786,28 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
- {"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'full' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "top", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'full' not supported with bitmap."}}
-
- -- Sync mode none tests --
-
-@@ -2821,26 +2821,26 @@ qemu_img compare "TEST_DIR/PID-img" "TEST_DIR/PID-fmirror3" ==> Identical, OK!
- {"error": {"class": "GenericError", "desc": "Cannot specify bitmap sync mode without a bitmap"}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "Dirty bitmap 'bitmap404' not found"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap404", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "on-success", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "always", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "bitmap-mode": "never", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "sync mode 'none' is not compatible with bitmaps"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
- {"execute": "blockdev-mirror", "arguments": {"bitmap": "bitmap0", "device": "drive0", "filter-node-name": "mirror-top", "job-id": "api_job", "sync": "none", "target": "mirror_target"}}
--{"error": {"class": "GenericError", "desc": "bitmap-mode must be specified if a bitmap is provided"}}
-+{"error": {"class": "GenericError", "desc": "Sync mode 'none' not supported with bitmap."}}
-
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Mon, 29 Jun 2020 11:06:03 +0200
-Subject: [PATCH] PVE-Backup: Add dirty-bitmap tracking for incremental backups
-
-Uses QEMU's existing MIRROR_SYNC_MODE_BITMAP and a dirty-bitmap on top
-of all backed-up drives. This will only execute the data-write callback
-for any changed chunks, the PBS rust code will reuse chunks from the
-previous index for everything it doesn't receive if reuse_index is true.
-
-On error or cancellation, remove all dirty bitmaps to ensure
-consistency.
-
-Add PBS/incremental specific information to query backup info QMP and
-HMP commands.
-
-Only supported for PBS backups.
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
-Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
-Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
----
- block/monitor/block-hmp-cmds.c | 1 +
- monitor/hmp-cmds.c | 45 ++++++++++++----
- proxmox-backup-client.c | 3 +-
- proxmox-backup-client.h | 1 +
- pve-backup.c | 95 ++++++++++++++++++++++++++++++----
- qapi/block-core.json | 12 ++++-
- 6 files changed, 134 insertions(+), 23 deletions(-)
-
-diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
-index d485c3ac79..fdc85a5c0e 100644
---- a/block/monitor/block-hmp-cmds.c
-+++ b/block/monitor/block-hmp-cmds.c
-@@ -1038,6 +1038,7 @@ void hmp_backup(Monitor *mon, const QDict *qdict)
- false, NULL, // PBS fingerprint
- false, NULL, // PBS backup-id
- false, 0, // PBS backup-time
-+ false, false, // PBS incremental
- true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
- false, NULL, false, NULL, !!devlist,
- devlist, qdict_haskey(qdict, "speed"), speed, &error);
-diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
-index 0e2d166552..3ff014d32a 100644
---- a/monitor/hmp-cmds.c
-+++ b/monitor/hmp-cmds.c
-@@ -218,19 +218,42 @@ void hmp_info_backup(Monitor *mon, const QDict *qdict)
- monitor_printf(mon, "End time: %s", ctime(&info->end_time));
- }
-
-- int per = (info->has_total && info->total &&
-- info->has_transferred && info->transferred) ?
-- (info->transferred * 100)/info->total : 0;
-- int zero_per = (info->has_total && info->total &&
-- info->has_zero_bytes && info->zero_bytes) ?
-- (info->zero_bytes * 100)/info->total : 0;
- monitor_printf(mon, "Backup file: %s\n", info->backup_file);
- monitor_printf(mon, "Backup uuid: %s\n", info->uuid);
-- monitor_printf(mon, "Total size: %zd\n", info->total);
-- monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
-- info->transferred, per);
-- monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
-- info->zero_bytes, zero_per);
-+
-+ if (!(info->has_total && info->total)) {
-+ // this should not happen normally
-+ monitor_printf(mon, "Total size: %d\n", 0);
-+ } else {
-+ bool incremental = false;
-+ size_t total_or_dirty = info->total;
-+ if (info->has_transferred) {
-+ if (info->has_dirty && info->dirty) {
-+ if (info->dirty < info->total) {
-+ total_or_dirty = info->dirty;
-+ incremental = true;
-+ }
-+ }
-+ }
-+
-+ int per = (info->transferred * 100)/total_or_dirty;
-+
-+ monitor_printf(mon, "Backup mode: %s\n", incremental ? "incremental" : "full");
-+
-+ int zero_per = (info->has_zero_bytes && info->zero_bytes) ?
-+ (info->zero_bytes * 100)/info->total : 0;
-+ monitor_printf(mon, "Total size: %zd\n", info->total);
-+ monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
-+ info->transferred, per);
-+ monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
-+ info->zero_bytes, zero_per);
-+
-+ if (info->has_reused) {
-+ int reused_per = (info->reused * 100)/total_or_dirty;
-+ monitor_printf(mon, "Reused bytes: %zd (%d%%)\n",
-+ info->reused, reused_per);
-+ }
-+ }
- }
-
- qapi_free_BackupStatus(info);
-diff --git a/proxmox-backup-client.c b/proxmox-backup-client.c
-index b7bc7f2574..0e9c584701 100644
---- a/proxmox-backup-client.c
-+++ b/proxmox-backup-client.c
-@@ -95,6 +95,7 @@ proxmox_backup_co_register_image(
- ProxmoxBackupHandle *pbs,
- const char *device_name,
- uint64_t size,
-+ bool incremental,
- Error **errp)
- {
- Coroutine *co = qemu_coroutine_self();
-@@ -104,7 +105,7 @@ proxmox_backup_co_register_image(
- int pbs_res = -1;
-
- proxmox_backup_register_image_async(
-- pbs, device_name, size ,proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
-+ pbs, device_name, size, incremental, proxmox_backup_schedule_wake, &waker, &pbs_res, &pbs_err);
- qemu_coroutine_yield();
- if (pbs_res < 0) {
- if (errp) error_setg(errp, "backup register image failed: %s", pbs_err ? pbs_err : "unknown error");
-diff --git a/proxmox-backup-client.h b/proxmox-backup-client.h
-index b311bf8de8..20fd6b1719 100644
---- a/proxmox-backup-client.h
-+++ b/proxmox-backup-client.h
-@@ -25,6 +25,7 @@ proxmox_backup_co_register_image(
- ProxmoxBackupHandle *pbs,
- const char *device_name,
- uint64_t size,
-+ bool incremental,
- Error **errp);
-
-
-diff --git a/pve-backup.c b/pve-backup.c
-index bb917ee972..7b5558e28e 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -28,6 +28,8 @@
- *
- */
-
-+const char *PBS_BITMAP_NAME = "pbs-incremental-dirty-bitmap";
-+
- static struct PVEBackupState {
- struct {
- // Everithing accessed from qmp_backup_query command is protected using lock
-@@ -39,7 +41,9 @@ static struct PVEBackupState {
- uuid_t uuid;
- char uuid_str[37];
- size_t total;
-+ size_t dirty;
- size_t transferred;
-+ size_t reused;
- size_t zero_bytes;
- } stat;
- int64_t speed;
-@@ -66,6 +70,7 @@ typedef struct PVEBackupDevInfo {
- uint8_t dev_id;
- bool completed;
- char targetfile[PATH_MAX];
-+ BdrvDirtyBitmap *bitmap;
- BlockDriverState *target;
- } PVEBackupDevInfo;
-
-@@ -105,11 +110,12 @@ static bool pvebackup_error_or_canceled(void)
- return error_or_canceled;
- }
-
--static void pvebackup_add_transfered_bytes(size_t transferred, size_t zero_bytes)
-+static void pvebackup_add_transfered_bytes(size_t transferred, size_t zero_bytes, size_t reused)
- {
- qemu_mutex_lock(&backup_state.stat.lock);
- backup_state.stat.zero_bytes += zero_bytes;
- backup_state.stat.transferred += transferred;
-+ backup_state.stat.reused += reused;
- qemu_mutex_unlock(&backup_state.stat.lock);
- }
-
-@@ -148,7 +154,8 @@ pvebackup_co_dump_pbs_cb(
- pvebackup_propagate_error(local_err);
- return pbs_res;
- } else {
-- pvebackup_add_transfered_bytes(size, !buf ? size : 0);
-+ size_t reused = (pbs_res == 0) ? size : 0;
-+ pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
- }
-
- return size;
-@@ -208,11 +215,11 @@ pvebackup_co_dump_vma_cb(
- } else {
- if (remaining >= VMA_CLUSTER_SIZE) {
- assert(ret == VMA_CLUSTER_SIZE);
-- pvebackup_add_transfered_bytes(VMA_CLUSTER_SIZE, zero_bytes);
-+ pvebackup_add_transfered_bytes(VMA_CLUSTER_SIZE, zero_bytes, 0);
- remaining -= VMA_CLUSTER_SIZE;
- } else {
- assert(ret == remaining);
-- pvebackup_add_transfered_bytes(remaining, zero_bytes);
-+ pvebackup_add_transfered_bytes(remaining, zero_bytes, 0);
- remaining = 0;
- }
- }
-@@ -248,6 +255,18 @@ static void coroutine_fn pvebackup_co_cleanup(void *unused)
- if (local_err != NULL) {
- pvebackup_propagate_error(local_err);
- }
-+ } else {
-+ // on error or cancel we cannot ensure synchronization of dirty
-+ // bitmaps with backup server, so remove all and do full backup next
-+ GList *l = backup_state.di_list;
-+ while (l) {
-+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ if (di->bitmap) {
-+ bdrv_release_dirty_bitmap(di->bitmap);
-+ }
-+ }
- }
-
- proxmox_backup_disconnect(backup_state.pbs);
-@@ -303,6 +322,12 @@ static void pvebackup_complete_cb(void *opaque, int ret)
- // remove self from job queue
- backup_state.di_list = g_list_remove(backup_state.di_list, di);
-
-+ if (di->bitmap && ret < 0) {
-+ // on error or cancel we cannot ensure synchronization of dirty
-+ // bitmaps with backup server, so remove all and do full backup next
-+ bdrv_release_dirty_bitmap(di->bitmap);
-+ }
-+
- g_free(di);
-
- qemu_mutex_unlock(&backup_state.backup_mutex);
-@@ -470,12 +495,18 @@ static bool create_backup_jobs(void) {
-
- assert(di->target != NULL);
-
-+ MirrorSyncMode sync_mode = MIRROR_SYNC_MODE_FULL;
-+ BitmapSyncMode bitmap_mode = BITMAP_SYNC_MODE_NEVER;
-+ if (di->bitmap) {
-+ sync_mode = MIRROR_SYNC_MODE_BITMAP;
-+ bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
-+ }
- AioContext *aio_context = bdrv_get_aio_context(di->bs);
- aio_context_acquire(aio_context);
-
- BlockJob *job = backup_job_create(
-- NULL, di->bs, di->target, backup_state.speed, MIRROR_SYNC_MODE_FULL, NULL,
-- BITMAP_SYNC_MODE_NEVER, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
-+ NULL, di->bs, di->target, backup_state.speed, sync_mode, di->bitmap,
-+ bitmap_mode, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
- JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
-
- aio_context_release(aio_context);
-@@ -526,6 +557,8 @@ typedef struct QmpBackupTask {
- const char *fingerprint;
- bool has_fingerprint;
- int64_t backup_time;
-+ bool has_incremental;
-+ bool incremental;
- bool has_format;
- BackupFormat format;
- bool has_config_file;
-@@ -621,6 +654,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- }
-
- size_t total = 0;
-+ size_t dirty = 0;
-
- l = di_list;
- while (l) {
-@@ -658,6 +692,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
- firewall_name = "fw.conf";
-
-+ bool incremental = task->has_incremental && task->incremental;
-+
- char *pbs_err = NULL;
- pbs = proxmox_backup_new(
- task->backup_file,
-@@ -677,7 +713,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- goto err;
- }
-
-- if (proxmox_backup_co_connect(pbs, task->errp) < 0)
-+ int connect_result = proxmox_backup_co_connect(pbs, task->errp);
-+ if (connect_result < 0)
- goto err;
-
- /* register all devices */
-@@ -688,9 +725,32 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
-
- const char *devname = bdrv_get_device_name(di->bs);
-
-- int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, task->errp);
-- if (dev_id < 0)
-+ BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
-+
-+ bool use_incremental = false;
-+ if (incremental) {
-+ if (bitmap == NULL) {
-+ bitmap = bdrv_create_dirty_bitmap(di->bs, dump_cb_block_size, PBS_BITMAP_NAME, task->errp);
-+ if (!bitmap) {
-+ goto err;
-+ }
-+ /* mark entire bitmap as dirty to make full backup first */
-+ bdrv_set_dirty_bitmap(bitmap, 0, di->size);
-+ dirty += di->size;
-+ } else {
-+ use_incremental = true;
-+ dirty += bdrv_get_dirty_count(bitmap);
-+ }
-+ di->bitmap = bitmap;
-+ } else if (bitmap != NULL) {
-+ dirty += di->size;
-+ bdrv_release_dirty_bitmap(bitmap);
-+ }
-+
-+ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, use_incremental, task->errp);
-+ if (dev_id < 0) {
- goto err;
-+ }
-
- if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_pbs_cb, di, task->errp))) {
- goto err;
-@@ -699,6 +759,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- di->dev_id = dev_id;
- }
- } else if (format == BACKUP_FORMAT_VMA) {
-+ dirty = total;
-+
- vmaw = vma_writer_create(task->backup_file, uuid, &local_err);
- if (!vmaw) {
- if (local_err) {
-@@ -726,6 +788,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- }
- }
- } else if (format == BACKUP_FORMAT_DIR) {
-+ dirty = total;
-+
- if (mkdir(task->backup_file, 0640) != 0) {
- error_setg_errno(task->errp, errno, "can't create directory '%s'\n",
- task->backup_file);
-@@ -798,8 +862,10 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- char *uuid_str = g_strdup(backup_state.stat.uuid_str);
-
- backup_state.stat.total = total;
-+ backup_state.stat.dirty = dirty;
- backup_state.stat.transferred = 0;
- backup_state.stat.zero_bytes = 0;
-+ backup_state.stat.reused = dirty >= total ? 0 : total - dirty;
-
- qemu_mutex_unlock(&backup_state.stat.lock);
-
-@@ -823,6 +889,10 @@ err:
- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
- l = g_list_next(l);
-
-+ if (di->bitmap) {
-+ bdrv_release_dirty_bitmap(di->bitmap);
-+ }
-+
- if (di->target) {
- bdrv_unref(di->target);
- }
-@@ -864,6 +934,7 @@ UuidInfo *qmp_backup(
- bool has_fingerprint, const char *fingerprint,
- bool has_backup_id, const char *backup_id,
- bool has_backup_time, int64_t backup_time,
-+ bool has_incremental, bool incremental,
- bool has_format, BackupFormat format,
- bool has_config_file, const char *config_file,
- bool has_firewall_file, const char *firewall_file,
-@@ -882,6 +953,8 @@ UuidInfo *qmp_backup(
- .backup_id = backup_id,
- .has_backup_time = has_backup_time,
- .backup_time = backup_time,
-+ .has_incremental = has_incremental,
-+ .incremental = incremental,
- .has_format = has_format,
- .format = format,
- .has_config_file = has_config_file,
-@@ -950,10 +1023,14 @@ BackupStatus *qmp_query_backup(Error **errp)
-
- info->has_total = true;
- info->total = backup_state.stat.total;
-+ info->has_dirty = true;
-+ info->dirty = backup_state.stat.dirty;
- info->has_zero_bytes = true;
- info->zero_bytes = backup_state.stat.zero_bytes;
- info->has_transferred = true;
- info->transferred = backup_state.stat.transferred;
-+ info->has_reused = true;
-+ info->reused = backup_state.stat.reused;
-
- qemu_mutex_unlock(&backup_state.stat.lock);
-
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index 9db8e26517..6cad1e0e38 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -767,8 +767,13 @@
- #
- # @total: total amount of bytes involved in the backup process
- #
-+# @dirty: with incremental mode, this is the amount of bytes involved
-+# in the backup process which are marked dirty.
-+#
- # @transferred: amount of bytes already backed up.
- #
-+# @reused: amount of bytes reused due to deduplication.
-+#
- # @zero-bytes: amount of 'zero' bytes detected.
- #
- # @start-time: time (epoch) when backup job started.
-@@ -781,8 +786,8 @@
- #
- ##
- { 'struct': 'BackupStatus',
-- 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int',
-- '*transferred': 'int', '*zero-bytes': 'int',
-+ 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int', '*dirty': 'int',
-+ '*transferred': 'int', '*zero-bytes': 'int', '*reused': 'int',
- '*start-time': 'int', '*end-time': 'int',
- '*backup-file': 'str', '*uuid': 'str' } }
-
-@@ -825,6 +830,8 @@
- #
- # @backup-time: backup timestamp (Unix epoch, required for format 'pbs')
- #
-+# @incremental: sync incremental changes since last job (optional for format 'pbs')
-+#
- # Returns: the uuid of the backup job
- #
- ##
-@@ -835,6 +842,7 @@
- '*fingerprint': 'str',
- '*backup-id': 'str',
- '*backup-time': 'int',
-+ '*incremental': 'bool',
- '*format': 'BackupFormat',
- '*config-file': 'str',
- '*firewall-file': 'str',
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Thomas Lamprecht <t.lamprecht@proxmox.com>
+Date: Mon, 6 Jul 2020 20:05:16 +0200
+Subject: [PATCH] PVE backup: rename incremental to use-dirty-bitmap
+
+Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+---
+ pve-backup.c | 22 +++++++++++-----------
+ qapi/block-core.json | 6 +++---
+ 2 files changed, 14 insertions(+), 14 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index d50f03a050..7bf54b4c5d 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -557,8 +557,8 @@ typedef struct QmpBackupTask {
+ const char *fingerprint;
+ bool has_fingerprint;
+ int64_t backup_time;
+- bool has_incremental;
+- bool incremental;
++ bool has_use_dirty_bitmap;
++ bool use_dirty_bitmap;
+ bool has_format;
+ BackupFormat format;
+ bool has_config_file;
+@@ -688,7 +688,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
+ firewall_name = "fw.conf";
+
+- bool incremental = task->has_incremental && task->incremental;
++ bool use_dirty_bitmap = task->has_use_dirty_bitmap && task->use_dirty_bitmap;
+
+ char *pbs_err = NULL;
+ pbs = proxmox_backup_new(
+@@ -722,9 +722,9 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ const char *devname = bdrv_get_device_name(di->bs);
+
+ BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
++ bool expect_only_dirty = false;
+
+- bool use_incremental = false;
+- if (incremental) {
++ if (use_dirty_bitmap) {
+ if (bitmap == NULL) {
+ bitmap = bdrv_create_dirty_bitmap(di->bs, dump_cb_block_size, PBS_BITMAP_NAME, task->errp);
+ if (!bitmap) {
+@@ -734,7 +734,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ bdrv_set_dirty_bitmap(bitmap, 0, di->size);
+ dirty += di->size;
+ } else {
+- use_incremental = true;
++ expect_only_dirty = true;
+ dirty += bdrv_get_dirty_count(bitmap);
+ }
+ di->bitmap = bitmap;
+@@ -743,7 +743,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ bdrv_release_dirty_bitmap(bitmap);
+ }
+
+- int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, use_incremental, task->errp);
++ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, expect_only_dirty, task->errp);
+ if (dev_id < 0) {
+ goto err;
+ }
+@@ -861,7 +861,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ backup_state.stat.dirty = dirty;
+ backup_state.stat.transferred = 0;
+ backup_state.stat.zero_bytes = 0;
+- backup_state.stat.reused = dirty >= total ? 0 : total - dirty;
++ backup_state.stat.reused = format == BACKUP_FORMAT_PBS && dirty >= total ? 0 : total - dirty;
+
+ qemu_mutex_unlock(&backup_state.stat.lock);
+
+@@ -930,7 +930,7 @@ UuidInfo *qmp_backup(
+ bool has_fingerprint, const char *fingerprint,
+ bool has_backup_id, const char *backup_id,
+ bool has_backup_time, int64_t backup_time,
+- bool has_incremental, bool incremental,
++ bool has_use_dirty_bitmap, bool use_dirty_bitmap,
+ bool has_format, BackupFormat format,
+ bool has_config_file, const char *config_file,
+ bool has_firewall_file, const char *firewall_file,
+@@ -949,8 +949,8 @@ UuidInfo *qmp_backup(
+ .backup_id = backup_id,
+ .has_backup_time = has_backup_time,
+ .backup_time = backup_time,
+- .has_incremental = has_incremental,
+- .incremental = incremental,
++ .has_use_dirty_bitmap = has_use_dirty_bitmap,
++ .use_dirty_bitmap = use_dirty_bitmap,
+ .has_format = has_format,
+ .format = format,
+ .has_config_file = has_config_file,
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index 6cad1e0e38..e00e577c6c 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -767,7 +767,7 @@
+ #
+ # @total: total amount of bytes involved in the backup process
+ #
+-# @dirty: with incremental mode, this is the amount of bytes involved
++# @dirty: with incremental mode (PBS) this is the amount of bytes involved
+ # in the backup process which are marked dirty.
+ #
+ # @transferred: amount of bytes already backed up.
+@@ -830,7 +830,7 @@
+ #
+ # @backup-time: backup timestamp (Unix epoch, required for format 'pbs')
+ #
+-# @incremental: sync incremental changes since last job (optional for format 'pbs')
++# @use-dirty-bitmap: use dirty bitmap to detect incremental changes since last job (optional for format 'pbs')
+ #
+ # Returns: the uuid of the backup job
+ #
+@@ -842,7 +842,7 @@
+ '*fingerprint': 'str',
+ '*backup-id': 'str',
+ '*backup-time': 'int',
+- '*incremental': 'bool',
++ '*use-dirty-bitmap': 'bool',
+ '*format': 'BackupFormat',
+ '*config-file': 'str',
+ '*firewall-file': 'str',
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Thomas Lamprecht <t.lamprecht@proxmox.com>
-Date: Mon, 6 Jul 2020 20:05:16 +0200
-Subject: [PATCH] PVE backup: rename incremental to use-dirty-bitmap
-
-Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
----
- pve-backup.c | 22 +++++++++++-----------
- qapi/block-core.json | 6 +++---
- 2 files changed, 14 insertions(+), 14 deletions(-)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index 7b5558e28e..9e767d724c 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -557,8 +557,8 @@ typedef struct QmpBackupTask {
- const char *fingerprint;
- bool has_fingerprint;
- int64_t backup_time;
-- bool has_incremental;
-- bool incremental;
-+ bool has_use_dirty_bitmap;
-+ bool use_dirty_bitmap;
- bool has_format;
- BackupFormat format;
- bool has_config_file;
-@@ -692,7 +692,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
- firewall_name = "fw.conf";
-
-- bool incremental = task->has_incremental && task->incremental;
-+ bool use_dirty_bitmap = task->has_use_dirty_bitmap && task->use_dirty_bitmap;
-
- char *pbs_err = NULL;
- pbs = proxmox_backup_new(
-@@ -726,9 +726,9 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- const char *devname = bdrv_get_device_name(di->bs);
-
- BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
-+ bool expect_only_dirty = false;
-
-- bool use_incremental = false;
-- if (incremental) {
-+ if (use_dirty_bitmap) {
- if (bitmap == NULL) {
- bitmap = bdrv_create_dirty_bitmap(di->bs, dump_cb_block_size, PBS_BITMAP_NAME, task->errp);
- if (!bitmap) {
-@@ -738,7 +738,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- bdrv_set_dirty_bitmap(bitmap, 0, di->size);
- dirty += di->size;
- } else {
-- use_incremental = true;
-+ expect_only_dirty = true;
- dirty += bdrv_get_dirty_count(bitmap);
- }
- di->bitmap = bitmap;
-@@ -747,7 +747,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- bdrv_release_dirty_bitmap(bitmap);
- }
-
-- int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, use_incremental, task->errp);
-+ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, expect_only_dirty, task->errp);
- if (dev_id < 0) {
- goto err;
- }
-@@ -865,7 +865,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- backup_state.stat.dirty = dirty;
- backup_state.stat.transferred = 0;
- backup_state.stat.zero_bytes = 0;
-- backup_state.stat.reused = dirty >= total ? 0 : total - dirty;
-+ backup_state.stat.reused = format == BACKUP_FORMAT_PBS && dirty >= total ? 0 : total - dirty;
-
- qemu_mutex_unlock(&backup_state.stat.lock);
-
-@@ -934,7 +934,7 @@ UuidInfo *qmp_backup(
- bool has_fingerprint, const char *fingerprint,
- bool has_backup_id, const char *backup_id,
- bool has_backup_time, int64_t backup_time,
-- bool has_incremental, bool incremental,
-+ bool has_use_dirty_bitmap, bool use_dirty_bitmap,
- bool has_format, BackupFormat format,
- bool has_config_file, const char *config_file,
- bool has_firewall_file, const char *firewall_file,
-@@ -953,8 +953,8 @@ UuidInfo *qmp_backup(
- .backup_id = backup_id,
- .has_backup_time = has_backup_time,
- .backup_time = backup_time,
-- .has_incremental = has_incremental,
-- .incremental = incremental,
-+ .has_use_dirty_bitmap = has_use_dirty_bitmap,
-+ .use_dirty_bitmap = use_dirty_bitmap,
- .has_format = has_format,
- .format = format,
- .has_config_file = has_config_file,
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index 6cad1e0e38..e00e577c6c 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -767,7 +767,7 @@
- #
- # @total: total amount of bytes involved in the backup process
- #
--# @dirty: with incremental mode, this is the amount of bytes involved
-+# @dirty: with incremental mode (PBS) this is the amount of bytes involved
- # in the backup process which are marked dirty.
- #
- # @transferred: amount of bytes already backed up.
-@@ -830,7 +830,7 @@
- #
- # @backup-time: backup timestamp (Unix epoch, required for format 'pbs')
- #
--# @incremental: sync incremental changes since last job (optional for format 'pbs')
-+# @use-dirty-bitmap: use dirty bitmap to detect incremental changes since last job (optional for format 'pbs')
- #
- # Returns: the uuid of the backup job
- #
-@@ -842,7 +842,7 @@
- '*fingerprint': 'str',
- '*backup-id': 'str',
- '*backup-time': 'int',
-- '*incremental': 'bool',
-+ '*use-dirty-bitmap': 'bool',
- '*format': 'BackupFormat',
- '*config-file': 'str',
- '*firewall-file': 'str',
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Mon, 6 Jul 2020 14:40:12 +0200
+Subject: [PATCH] PVE: fixup pbs-restore API
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+---
+ pbs-restore.c | 10 ++++++++--
+ 1 file changed, 8 insertions(+), 2 deletions(-)
+
+diff --git a/pbs-restore.c b/pbs-restore.c
+index 4bf37ef1fa..ff3fc38e8a 100644
+--- a/pbs-restore.c
++++ b/pbs-restore.c
+@@ -161,13 +161,19 @@ int main(int argc, char **argv)
+ fprintf(stderr, "connecting to repository '%s'\n", repository);
+ }
+ char *pbs_error = NULL;
+- ProxmoxRestoreHandle *conn = proxmox_restore_connect(
++ ProxmoxRestoreHandle *conn = proxmox_restore_new(
+ repository, snapshot, password, keyfile, key_password, fingerprint, &pbs_error);
+ if (conn == NULL) {
+ fprintf(stderr, "restore failed: %s\n", pbs_error);
+ return -1;
+ }
+
++ int res = proxmox_restore_connect(conn, &pbs_error);
++ if (res < 0 || pbs_error) {
++ fprintf(stderr, "restore failed (connection error): %s\n", pbs_error);
++ return -1;
++ }
++
+ QDict *options = qdict_new();
+
+ if (format) {
+@@ -198,7 +204,7 @@ int main(int argc, char **argv)
+ fprintf(stderr, "starting to restore snapshot '%s'\n", snapshot);
+ fflush(stderr); // ensure we do not get printed after the progress log
+ }
+- int res = proxmox_restore_image(
++ res = proxmox_restore_image(
+ conn,
+ archive_name,
+ write_callback,
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Mon, 6 Jul 2020 14:40:13 +0200
+Subject: [PATCH] PVE: always set dirty counter for non-incremental backups
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+---
+ pve-backup.c | 8 ++++++--
+ 1 file changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 7bf54b4c5d..1f2a0bbe8c 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -738,9 +738,13 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ dirty += bdrv_get_dirty_count(bitmap);
+ }
+ di->bitmap = bitmap;
+- } else if (bitmap != NULL) {
++ } else {
+ dirty += di->size;
+- bdrv_release_dirty_bitmap(bitmap);
++
++ /* after a full backup the old dirty bitmap is invalid anyway */
++ if (bitmap != NULL) {
++ bdrv_release_dirty_bitmap(bitmap);
++ }
+ }
+
+ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, expect_only_dirty, task->errp);
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Mon, 6 Jul 2020 14:40:12 +0200
-Subject: [PATCH] PVE: fixup pbs-restore API
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
----
- pbs-restore.c | 10 ++++++++--
- 1 file changed, 8 insertions(+), 2 deletions(-)
-
-diff --git a/pbs-restore.c b/pbs-restore.c
-index 4bf37ef1fa..ff3fc38e8a 100644
---- a/pbs-restore.c
-+++ b/pbs-restore.c
-@@ -161,13 +161,19 @@ int main(int argc, char **argv)
- fprintf(stderr, "connecting to repository '%s'\n", repository);
- }
- char *pbs_error = NULL;
-- ProxmoxRestoreHandle *conn = proxmox_restore_connect(
-+ ProxmoxRestoreHandle *conn = proxmox_restore_new(
- repository, snapshot, password, keyfile, key_password, fingerprint, &pbs_error);
- if (conn == NULL) {
- fprintf(stderr, "restore failed: %s\n", pbs_error);
- return -1;
- }
-
-+ int res = proxmox_restore_connect(conn, &pbs_error);
-+ if (res < 0 || pbs_error) {
-+ fprintf(stderr, "restore failed (connection error): %s\n", pbs_error);
-+ return -1;
-+ }
-+
- QDict *options = qdict_new();
-
- if (format) {
-@@ -198,7 +204,7 @@ int main(int argc, char **argv)
- fprintf(stderr, "starting to restore snapshot '%s'\n", snapshot);
- fflush(stderr); // ensure we do not get printed after the progress log
- }
-- int res = proxmox_restore_image(
-+ res = proxmox_restore_image(
- conn,
- archive_name,
- write_callback,
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Mon, 6 Jul 2020 14:40:13 +0200
-Subject: [PATCH] PVE: always set dirty counter for non-incremental backups
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
----
- pve-backup.c | 8 ++++++--
- 1 file changed, 6 insertions(+), 2 deletions(-)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index 9e767d724c..c108f6a745 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -742,9 +742,13 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- dirty += bdrv_get_dirty_count(bitmap);
- }
- di->bitmap = bitmap;
-- } else if (bitmap != NULL) {
-+ } else {
- dirty += di->size;
-- bdrv_release_dirty_bitmap(bitmap);
-+
-+ /* after a full backup the old dirty bitmap is invalid anyway */
-+ if (bitmap != NULL) {
-+ bdrv_release_dirty_bitmap(bitmap);
-+ }
- }
-
- int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, expect_only_dirty, task->errp);
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Mon, 6 Jul 2020 14:40:14 +0200
+Subject: [PATCH] PVE: use proxmox_backup_check_incremental
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
+---
+ pve-backup.c | 12 ++++++++----
+ 1 file changed, 8 insertions(+), 4 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 1f2a0bbe8c..1cd9d31d7c 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -730,12 +730,16 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ if (!bitmap) {
+ goto err;
+ }
+- /* mark entire bitmap as dirty to make full backup first */
+- bdrv_set_dirty_bitmap(bitmap, 0, di->size);
+- dirty += di->size;
+ } else {
+- expect_only_dirty = true;
++ expect_only_dirty = proxmox_backup_check_incremental(pbs, devname, di->size) != 0;
++ }
++
++ if (expect_only_dirty) {
+ dirty += bdrv_get_dirty_count(bitmap);
++ } else {
++ /* mark entire bitmap as dirty to make full backup */
++ bdrv_set_dirty_bitmap(bitmap, 0, di->size);
++ dirty += di->size;
+ }
+ di->bitmap = bitmap;
+ } else {
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dietmar Maurer <dietmar@proxmox.com>
+Date: Thu, 9 Jul 2020 12:53:08 +0200
+Subject: [PATCH] PVE: fixup pbs backup, add compress and encrypt options
+
+---
+ block/monitor/block-hmp-cmds.c | 4 +++-
+ pve-backup.c | 13 ++++++++++++-
+ qapi/block-core.json | 6 ++++++
+ 3 files changed, 21 insertions(+), 2 deletions(-)
+
+diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
+index fdc85a5c0e..43aa87487b 100644
+--- a/block/monitor/block-hmp-cmds.c
++++ b/block/monitor/block-hmp-cmds.c
+@@ -1038,7 +1038,9 @@ void hmp_backup(Monitor *mon, const QDict *qdict)
+ false, NULL, // PBS fingerprint
+ false, NULL, // PBS backup-id
+ false, 0, // PBS backup-time
+- false, false, // PBS incremental
++ false, false, // PBS use-dirty-bitmap
++ false, false, // PBS compress
++ false, false, // PBS encrypt
+ true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
+ false, NULL, false, NULL, !!devlist,
+ devlist, qdict_haskey(qdict, "speed"), speed, &error);
+diff --git a/pve-backup.c b/pve-backup.c
+index 1cd9d31d7c..bfb648d6b5 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -567,6 +567,10 @@ typedef struct QmpBackupTask {
+ const char *firewall_file;
+ bool has_devlist;
+ const char *devlist;
++ bool has_compress;
++ bool compress;
++ bool has_encrypt;
++ bool encrypt;
+ bool has_speed;
+ int64_t speed;
+ Error **errp;
+@@ -690,6 +694,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+
+ bool use_dirty_bitmap = task->has_use_dirty_bitmap && task->use_dirty_bitmap;
+
++
+ char *pbs_err = NULL;
+ pbs = proxmox_backup_new(
+ task->backup_file,
+@@ -699,8 +704,10 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ task->has_password ? task->password : NULL,
+ task->has_keyfile ? task->keyfile : NULL,
+ task->has_key_password ? task->key_password : NULL,
++ task->has_compress ? task->compress : true,
++ task->has_encrypt ? task->encrypt : task->has_keyfile,
+ task->has_fingerprint ? task->fingerprint : NULL,
+- &pbs_err);
++ &pbs_err);
+
+ if (!pbs) {
+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
+@@ -939,6 +946,8 @@ UuidInfo *qmp_backup(
+ bool has_backup_id, const char *backup_id,
+ bool has_backup_time, int64_t backup_time,
+ bool has_use_dirty_bitmap, bool use_dirty_bitmap,
++ bool has_compress, bool compress,
++ bool has_encrypt, bool encrypt,
+ bool has_format, BackupFormat format,
+ bool has_config_file, const char *config_file,
+ bool has_firewall_file, const char *firewall_file,
+@@ -967,6 +976,8 @@ UuidInfo *qmp_backup(
+ .firewall_file = firewall_file,
+ .has_devlist = has_devlist,
+ .devlist = devlist,
++ .has_compress = has_compress,
++ .has_encrypt = has_encrypt,
+ .has_speed = has_speed,
+ .speed = speed,
+ .errp = errp,
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index e00e577c6c..a177fea6cd 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -832,6 +832,10 @@
+ #
+ # @use-dirty-bitmap: use dirty bitmap to detect incremental changes since last job (optional for format 'pbs')
+ #
++# @compress: use compression (optional for format 'pbs', defaults to true)
++#
++# @encrypt: use encryption ((optional for format 'pbs', defaults to true if there is a keyfile)
++#
+ # Returns: the uuid of the backup job
+ #
+ ##
+@@ -843,6 +847,8 @@
+ '*backup-id': 'str',
+ '*backup-time': 'int',
+ '*use-dirty-bitmap': 'bool',
++ '*compress': 'bool',
++ '*encrypt': 'bool',
+ '*format': 'BackupFormat',
+ '*config-file': 'str',
+ '*firewall-file': 'str',
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Mon, 6 Jul 2020 14:40:14 +0200
-Subject: [PATCH] PVE: use proxmox_backup_check_incremental
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
-Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
----
- pve-backup.c | 12 ++++++++----
- 1 file changed, 8 insertions(+), 4 deletions(-)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index c108f6a745..aa62a1da16 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -734,12 +734,16 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- if (!bitmap) {
- goto err;
- }
-- /* mark entire bitmap as dirty to make full backup first */
-- bdrv_set_dirty_bitmap(bitmap, 0, di->size);
-- dirty += di->size;
- } else {
-- expect_only_dirty = true;
-+ expect_only_dirty = proxmox_backup_check_incremental(pbs, devname, di->size) != 0;
-+ }
-+
-+ if (expect_only_dirty) {
- dirty += bdrv_get_dirty_count(bitmap);
-+ } else {
-+ /* mark entire bitmap as dirty to make full backup */
-+ bdrv_set_dirty_bitmap(bitmap, 0, di->size);
-+ dirty += di->size;
- }
- di->bitmap = bitmap;
- } else {
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Wed, 8 Jul 2020 09:50:54 +0200
+Subject: [PATCH] PVE: Add PBS block driver to map backup archives into VMs
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+[error cleanups, file_open implementation]
+Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
+---
+ block/Makefile.objs | 2 +
+ block/pbs.c | 271 +++++++++++++++++++++++++++++++++++++++++++
+ configure | 10 ++
+ qapi/block-core.json | 14 ++-
+ 4 files changed, 296 insertions(+), 1 deletion(-)
+ create mode 100644 block/pbs.c
+
+diff --git a/block/Makefile.objs b/block/Makefile.objs
+index 9ea0477d0b..28fb3b7f7c 100644
+--- a/block/Makefile.objs
++++ b/block/Makefile.objs
+@@ -5,6 +5,7 @@ block-obj-$(CONFIG_CLOOP) += cloop.o
+ block-obj-$(CONFIG_BOCHS) += bochs.o
+ block-obj-$(CONFIG_VVFAT) += vvfat.o
+ block-obj-$(CONFIG_DMG) += dmg.o
++block-obj-$(CONFIG_PBS_BDRV) += pbs.o
+
+ block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o qcow2-bitmap.o qcow2-threads.o
+ block-obj-$(CONFIG_QED) += qed.o qed-l2-cache.o qed-table.o qed-cluster.o
+@@ -75,3 +76,4 @@ io_uring.o-cflags := $(LINUX_IO_URING_CFLAGS)
+ io_uring.o-libs := $(LINUX_IO_URING_LIBS)
+ parallels.o-cflags := $(LIBXML2_CFLAGS)
+ parallels.o-libs := $(LIBXML2_LIBS)
++pbs.o-libs := -lproxmox_backup_qemu
+diff --git a/block/pbs.c b/block/pbs.c
+new file mode 100644
+index 0000000000..1481a2bfd1
+--- /dev/null
++++ b/block/pbs.c
+@@ -0,0 +1,271 @@
++/*
++ * Proxmox Backup Server read-only block driver
++ */
++
++#include "qemu/osdep.h"
++#include "qapi/error.h"
++#include "qapi/qmp/qdict.h"
++#include "qapi/qmp/qstring.h"
++#include "qemu/module.h"
++#include "qemu/option.h"
++#include "qemu/cutils.h"
++#include "block/block_int.h"
++
++#include <proxmox-backup-qemu.h>
++
++#define PBS_OPT_REPOSITORY "repository"
++#define PBS_OPT_SNAPSHOT "snapshot"
++#define PBS_OPT_ARCHIVE "archive"
++#define PBS_OPT_KEYFILE "keyfile"
++#define PBS_OPT_PASSWORD "password"
++#define PBS_OPT_FINGERPRINT "fingerprint"
++#define PBS_OPT_ENCRYPTION_PASSWORD "key_password"
++
++typedef struct {
++ ProxmoxRestoreHandle *conn;
++ char aid;
++ int64_t length;
++
++ char *repository;
++ char *snapshot;
++ char *archive;
++} BDRVPBSState;
++
++static QemuOptsList runtime_opts = {
++ .name = "pbs",
++ .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
++ .desc = {
++ {
++ .name = PBS_OPT_REPOSITORY,
++ .type = QEMU_OPT_STRING,
++ .help = "The server address and repository to connect to.",
++ },
++ {
++ .name = PBS_OPT_SNAPSHOT,
++ .type = QEMU_OPT_STRING,
++ .help = "The snapshot to read.",
++ },
++ {
++ .name = PBS_OPT_ARCHIVE,
++ .type = QEMU_OPT_STRING,
++ .help = "Which archive within the snapshot should be accessed.",
++ },
++ {
++ .name = PBS_OPT_PASSWORD,
++ .type = QEMU_OPT_STRING,
++ .help = "Server password. Can be passed as env var 'PBS_PASSWORD'.",
++ },
++ {
++ .name = PBS_OPT_FINGERPRINT,
++ .type = QEMU_OPT_STRING,
++ .help = "Server fingerprint. Can be passed as env var 'PBS_FINGERPRINT'.",
++ },
++ {
++ .name = PBS_OPT_ENCRYPTION_PASSWORD,
++ .type = QEMU_OPT_STRING,
++ .help = "Optional: Key password. Can be passed as env var 'PBS_ENCRYPTION_PASSWORD'.",
++ },
++ {
++ .name = PBS_OPT_KEYFILE,
++ .type = QEMU_OPT_STRING,
++ .help = "Optional: The path to the keyfile to use.",
++ },
++ { /* end of list */ }
++ },
++};
++
++
++// filename format:
++// pbs:repository=<repo>,snapshot=<snap>,password=<pw>,key_password=<kpw>,fingerprint=<fp>,archive=<archive>
++static void pbs_parse_filename(const char *filename, QDict *options,
++ Error **errp)
++{
++
++ if (!strstart(filename, "pbs:", &filename)) {
++ if (errp) error_setg(errp, "pbs_parse_filename failed - missing 'pbs:' prefix");
++ }
++
++
++ QemuOpts *opts = qemu_opts_parse_noisily(&runtime_opts, filename, false);
++ if (!opts) {
++ if (errp) error_setg(errp, "pbs_parse_filename failed");
++ return;
++ }
++
++ qemu_opts_to_qdict(opts, options);
++
++ qemu_opts_del(opts);
++}
++
++static int pbs_open(BlockDriverState *bs, QDict *options, int flags,
++ Error **errp)
++{
++ QemuOpts *opts;
++ BDRVPBSState *s = bs->opaque;
++ char *pbs_error = NULL;
++
++ opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
++ qemu_opts_absorb_qdict(opts, options, &error_abort);
++
++ s->repository = g_strdup(qemu_opt_get(opts, PBS_OPT_REPOSITORY));
++ s->snapshot = g_strdup(qemu_opt_get(opts, PBS_OPT_SNAPSHOT));
++ s->archive = g_strdup(qemu_opt_get(opts, PBS_OPT_ARCHIVE));
++ const char *keyfile = qemu_opt_get(opts, PBS_OPT_KEYFILE);
++ const char *password = qemu_opt_get(opts, PBS_OPT_PASSWORD);
++ const char *fingerprint = qemu_opt_get(opts, PBS_OPT_FINGERPRINT);
++ const char *key_password = qemu_opt_get(opts, PBS_OPT_ENCRYPTION_PASSWORD);
++
++ if (!password) {
++ password = getenv("PBS_PASSWORD");
++ }
++ if (!fingerprint) {
++ fingerprint = getenv("PBS_FINGERPRINT");
++ }
++ if (!key_password) {
++ key_password = getenv("PBS_ENCRYPTION_PASSWORD");
++ }
++
++ /* connect to PBS server in read mode */
++ s->conn = proxmox_restore_new(s->repository, s->snapshot, password,
++ keyfile, key_password, fingerprint, &pbs_error);
++
++ /* invalidates qemu_opt_get char pointers from above */
++ qemu_opts_del(opts);
++
++ if (!s->conn) {
++ if (pbs_error && errp) error_setg(errp, "PBS restore_new failed: %s", pbs_error);
++ if (pbs_error) proxmox_backup_free_error(pbs_error);
++ return -ENOMEM;
++ }
++
++ int ret = proxmox_restore_connect(s->conn, &pbs_error);
++ if (ret < 0) {
++ if (pbs_error && errp) error_setg(errp, "PBS connect failed: %s", pbs_error);
++ if (pbs_error) proxmox_backup_free_error(pbs_error);
++ return -ECONNREFUSED;
++ }
++
++ /* acquire handle and length */
++ s->aid = proxmox_restore_open_image(s->conn, s->archive, &pbs_error);
++ if (s->aid < 0) {
++ if (pbs_error && errp) error_setg(errp, "PBS open_image failed: %s", pbs_error);
++ if (pbs_error) proxmox_backup_free_error(pbs_error);
++ return -ENODEV;
++ }
++ s->length = proxmox_restore_get_image_length(s->conn, s->aid, &pbs_error);
++ if (s->length < 0) {
++ if (pbs_error && errp) error_setg(errp, "PBS get_image_length failed: %s", pbs_error);
++ if (pbs_error) proxmox_backup_free_error(pbs_error);
++ return -EINVAL;
++ }
++
++ return 0;
++}
++
++static int pbs_file_open(BlockDriverState *bs, QDict *options, int flags,
++ Error **errp)
++{
++ return pbs_open(bs, options, flags, errp);
++}
++
++static void pbs_close(BlockDriverState *bs) {
++ BDRVPBSState *s = bs->opaque;
++ g_free(s->repository);
++ g_free(s->snapshot);
++ g_free(s->archive);
++ proxmox_restore_disconnect(s->conn);
++}
++
++static int64_t pbs_getlength(BlockDriverState *bs)
++{
++ BDRVPBSState *s = bs->opaque;
++ return s->length;
++}
++
++typedef struct ReadCallbackData {
++ Coroutine *co;
++ AioContext *ctx;
++} ReadCallbackData;
++
++static void read_callback(void *callback_data)
++{
++ ReadCallbackData *rcb = callback_data;
++ aio_co_schedule(rcb->ctx, rcb->co);
++}
++
++static coroutine_fn int pbs_co_preadv(BlockDriverState *bs,
++ uint64_t offset, uint64_t bytes,
++ QEMUIOVector *qiov, int flags)
++{
++ BDRVPBSState *s = bs->opaque;
++ int ret;
++ char *pbs_error = NULL;
++ uint8_t *buf = malloc(bytes);
++
++ ReadCallbackData rcb = {
++ .co = qemu_coroutine_self(),
++ .ctx = qemu_get_current_aio_context(),
++ };
++
++ proxmox_restore_read_image_at_async(s->conn, s->aid, buf, offset, bytes,
++ read_callback, (void *) &rcb, &ret, &pbs_error);
++
++ qemu_coroutine_yield();
++
++ if (ret < 0) {
++ fprintf(stderr, "error during PBS read: %s\n", pbs_error ? pbs_error : "unknown error");
++ if (pbs_error) proxmox_backup_free_error(pbs_error);
++ return -EIO;
++ }
++
++ qemu_iovec_from_buf(qiov, 0, buf, bytes);
++ free(buf);
++
++ return ret;
++}
++
++static coroutine_fn int pbs_co_pwritev(BlockDriverState *bs,
++ uint64_t offset, uint64_t bytes,
++ QEMUIOVector *qiov, int flags)
++{
++ fprintf(stderr, "pbs-bdrv: cannot write to backup file, make sure "
++ "any attached disk devices are set to read-only!\n");
++ return -EPERM;
++}
++
++static void pbs_refresh_filename(BlockDriverState *bs)
++{
++ BDRVPBSState *s = bs->opaque;
++ snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s/%s(%s)",
++ s->repository, s->snapshot, s->archive);
++}
++
++static const char *const pbs_strong_runtime_opts[] = {
++ NULL
++};
++
++static BlockDriver bdrv_pbs_co = {
++ .format_name = "pbs",
++ .protocol_name = "pbs",
++ .instance_size = sizeof(BDRVPBSState),
++
++ .bdrv_parse_filename = pbs_parse_filename,
++
++ .bdrv_file_open = pbs_file_open,
++ .bdrv_open = pbs_open,
++ .bdrv_close = pbs_close,
++ .bdrv_getlength = pbs_getlength,
++
++ .bdrv_co_preadv = pbs_co_preadv,
++ .bdrv_co_pwritev = pbs_co_pwritev,
++
++ .bdrv_refresh_filename = pbs_refresh_filename,
++ .strong_runtime_opts = pbs_strong_runtime_opts,
++};
++
++static void bdrv_pbs_init(void)
++{
++ bdrv_register(&bdrv_pbs_co);
++}
++
++block_init(bdrv_pbs_init);
+diff --git a/configure b/configure
+index 2acc4d1465..3fc80d0c2c 100755
+--- a/configure
++++ b/configure
+@@ -510,6 +510,7 @@ vvfat="yes"
+ qed="yes"
+ parallels="yes"
+ sheepdog="yes"
++pbs_bdrv="yes"
+ libxml2=""
+ debug_mutex="no"
+ libpmem=""
+@@ -1576,6 +1577,10 @@ for opt do
+ ;;
+ --enable-sheepdog) sheepdog="yes"
+ ;;
++ --disable-pbs-bdrv) pbs_bdrv="no"
++ ;;
++ --enable-pbs-bdrv) pbs_bdrv="yes"
++ ;;
+ --disable-vhost-user) vhost_user="no"
+ ;;
+ --enable-vhost-user) vhost_user="yes"
+@@ -1936,6 +1941,7 @@ disabled with --disable-FEATURE, default is enabled if available:
+ qed qed image format support
+ parallels parallels image format support
+ sheepdog sheepdog block driver support
++ pbs-bdrv Proxmox backup server read-only block driver support
+ crypto-afalg Linux AF_ALG crypto backend driver
+ capstone capstone disassembler support
+ debug-mutex mutex debugging support
+@@ -7009,6 +7015,7 @@ echo "vvfat support $vvfat"
+ echo "qed support $qed"
+ echo "parallels support $parallels"
+ echo "sheepdog support $sheepdog"
++echo "pbs-bdrv support $pbs_bdrv"
+ echo "capstone $capstone"
+ echo "libpmem support $libpmem"
+ echo "libdaxctl support $libdaxctl"
+@@ -7885,6 +7892,9 @@ fi
+ if test "$sheepdog" = "yes" ; then
+ echo "CONFIG_SHEEPDOG=y" >> $config_host_mak
+ fi
++if test "$pbs_bdrv" = "yes" ; then
++ echo "CONFIG_PBS_BDRV=y" >> $config_host_mak
++fi
+ if test "$pty_h" = "yes" ; then
+ echo "HAVE_PTY_H=y" >> $config_host_mak
+ fi
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index a177fea6cd..f782c2cf96 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -2951,7 +2951,7 @@
+ 'luks', 'nbd', 'nfs', 'null-aio', 'null-co', 'nvme', 'parallels',
+ 'qcow', 'qcow2', 'qed', 'quorum', 'raw', 'rbd',
+ { 'name': 'replication', 'if': 'defined(CONFIG_REPLICATION)' },
+- 'sheepdog',
++ 'sheepdog', 'pbs',
+ 'ssh', 'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
+
+ ##
+@@ -3015,6 +3015,17 @@
+ { 'struct': 'BlockdevOptionsNull',
+ 'data': { '*size': 'int', '*latency-ns': 'uint64', '*read-zeroes': 'bool' } }
+
++##
++# @BlockdevOptionsPbs:
++#
++# Driver specific block device options for the PBS backend.
++#
++##
++{ 'struct': 'BlockdevOptionsPbs',
++ 'data': { 'repository': 'str', 'snapshot': 'str', 'archive': 'str',
++ '*keyfile': 'str', '*password': 'str', '*fingerprint': 'str',
++ '*key_password': 'str' } }
++
+ ##
+ # @BlockdevOptionsNVMe:
+ #
+@@ -4121,6 +4132,7 @@
+ 'nfs': 'BlockdevOptionsNfs',
+ 'null-aio': 'BlockdevOptionsNull',
+ 'null-co': 'BlockdevOptionsNull',
++ 'pbs': 'BlockdevOptionsPbs',
+ 'nvme': 'BlockdevOptionsNVMe',
+ 'parallels': 'BlockdevOptionsGenericFormat',
+ 'qcow2': 'BlockdevOptionsQcow2',
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Dietmar Maurer <dietmar@proxmox.com>
-Date: Thu, 9 Jul 2020 12:53:08 +0200
-Subject: [PATCH] PVE: fixup pbs backup, add compress and encrypt options
-
----
- block/monitor/block-hmp-cmds.c | 4 +++-
- pve-backup.c | 13 ++++++++++++-
- qapi/block-core.json | 6 ++++++
- 3 files changed, 21 insertions(+), 2 deletions(-)
-
-diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
-index fdc85a5c0e..43aa87487b 100644
---- a/block/monitor/block-hmp-cmds.c
-+++ b/block/monitor/block-hmp-cmds.c
-@@ -1038,7 +1038,9 @@ void hmp_backup(Monitor *mon, const QDict *qdict)
- false, NULL, // PBS fingerprint
- false, NULL, // PBS backup-id
- false, 0, // PBS backup-time
-- false, false, // PBS incremental
-+ false, false, // PBS use-dirty-bitmap
-+ false, false, // PBS compress
-+ false, false, // PBS encrypt
- true, dir ? BACKUP_FORMAT_DIR : BACKUP_FORMAT_VMA,
- false, NULL, false, NULL, !!devlist,
- devlist, qdict_haskey(qdict, "speed"), speed, &error);
-diff --git a/pve-backup.c b/pve-backup.c
-index aa62a1da16..343035b5c9 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -567,6 +567,10 @@ typedef struct QmpBackupTask {
- const char *firewall_file;
- bool has_devlist;
- const char *devlist;
-+ bool has_compress;
-+ bool compress;
-+ bool has_encrypt;
-+ bool encrypt;
- bool has_speed;
- int64_t speed;
- Error **errp;
-@@ -694,6 +698,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
-
- bool use_dirty_bitmap = task->has_use_dirty_bitmap && task->use_dirty_bitmap;
-
-+
- char *pbs_err = NULL;
- pbs = proxmox_backup_new(
- task->backup_file,
-@@ -703,8 +708,10 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- task->has_password ? task->password : NULL,
- task->has_keyfile ? task->keyfile : NULL,
- task->has_key_password ? task->key_password : NULL,
-+ task->has_compress ? task->compress : true,
-+ task->has_encrypt ? task->encrypt : task->has_keyfile,
- task->has_fingerprint ? task->fingerprint : NULL,
-- &pbs_err);
-+ &pbs_err);
-
- if (!pbs) {
- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
-@@ -943,6 +950,8 @@ UuidInfo *qmp_backup(
- bool has_backup_id, const char *backup_id,
- bool has_backup_time, int64_t backup_time,
- bool has_use_dirty_bitmap, bool use_dirty_bitmap,
-+ bool has_compress, bool compress,
-+ bool has_encrypt, bool encrypt,
- bool has_format, BackupFormat format,
- bool has_config_file, const char *config_file,
- bool has_firewall_file, const char *firewall_file,
-@@ -971,6 +980,8 @@ UuidInfo *qmp_backup(
- .firewall_file = firewall_file,
- .has_devlist = has_devlist,
- .devlist = devlist,
-+ .has_compress = has_compress,
-+ .has_encrypt = has_encrypt,
- .has_speed = has_speed,
- .speed = speed,
- .errp = errp,
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index e00e577c6c..a177fea6cd 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -832,6 +832,10 @@
- #
- # @use-dirty-bitmap: use dirty bitmap to detect incremental changes since last job (optional for format 'pbs')
- #
-+# @compress: use compression (optional for format 'pbs', defaults to true)
-+#
-+# @encrypt: use encryption ((optional for format 'pbs', defaults to true if there is a keyfile)
-+#
- # Returns: the uuid of the backup job
- #
- ##
-@@ -843,6 +847,8 @@
- '*backup-id': 'str',
- '*backup-time': 'int',
- '*use-dirty-bitmap': 'bool',
-+ '*compress': 'bool',
-+ '*encrypt': 'bool',
- '*format': 'BackupFormat',
- '*config-file': 'str',
- '*firewall-file': 'str',
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Wed, 8 Jul 2020 09:50:54 +0200
-Subject: [PATCH] PVE: Add PBS block driver to map backup archives into VMs
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
-[error cleanups, file_open implementation]
-Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
----
- block/Makefile.objs | 2 +
- block/pbs.c | 271 +++++++++++++++++++++++++++++++++++++++++++
- configure | 10 ++
- qapi/block-core.json | 14 ++-
- 4 files changed, 296 insertions(+), 1 deletion(-)
- create mode 100644 block/pbs.c
-
-diff --git a/block/Makefile.objs b/block/Makefile.objs
-index 9ea0477d0b..28fb3b7f7c 100644
---- a/block/Makefile.objs
-+++ b/block/Makefile.objs
-@@ -5,6 +5,7 @@ block-obj-$(CONFIG_CLOOP) += cloop.o
- block-obj-$(CONFIG_BOCHS) += bochs.o
- block-obj-$(CONFIG_VVFAT) += vvfat.o
- block-obj-$(CONFIG_DMG) += dmg.o
-+block-obj-$(CONFIG_PBS_BDRV) += pbs.o
-
- block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o qcow2-bitmap.o qcow2-threads.o
- block-obj-$(CONFIG_QED) += qed.o qed-l2-cache.o qed-table.o qed-cluster.o
-@@ -75,3 +76,4 @@ io_uring.o-cflags := $(LINUX_IO_URING_CFLAGS)
- io_uring.o-libs := $(LINUX_IO_URING_LIBS)
- parallels.o-cflags := $(LIBXML2_CFLAGS)
- parallels.o-libs := $(LIBXML2_LIBS)
-+pbs.o-libs := -lproxmox_backup_qemu
-diff --git a/block/pbs.c b/block/pbs.c
-new file mode 100644
-index 0000000000..1481a2bfd1
---- /dev/null
-+++ b/block/pbs.c
-@@ -0,0 +1,271 @@
-+/*
-+ * Proxmox Backup Server read-only block driver
-+ */
-+
-+#include "qemu/osdep.h"
-+#include "qapi/error.h"
-+#include "qapi/qmp/qdict.h"
-+#include "qapi/qmp/qstring.h"
-+#include "qemu/module.h"
-+#include "qemu/option.h"
-+#include "qemu/cutils.h"
-+#include "block/block_int.h"
-+
-+#include <proxmox-backup-qemu.h>
-+
-+#define PBS_OPT_REPOSITORY "repository"
-+#define PBS_OPT_SNAPSHOT "snapshot"
-+#define PBS_OPT_ARCHIVE "archive"
-+#define PBS_OPT_KEYFILE "keyfile"
-+#define PBS_OPT_PASSWORD "password"
-+#define PBS_OPT_FINGERPRINT "fingerprint"
-+#define PBS_OPT_ENCRYPTION_PASSWORD "key_password"
-+
-+typedef struct {
-+ ProxmoxRestoreHandle *conn;
-+ char aid;
-+ int64_t length;
-+
-+ char *repository;
-+ char *snapshot;
-+ char *archive;
-+} BDRVPBSState;
-+
-+static QemuOptsList runtime_opts = {
-+ .name = "pbs",
-+ .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
-+ .desc = {
-+ {
-+ .name = PBS_OPT_REPOSITORY,
-+ .type = QEMU_OPT_STRING,
-+ .help = "The server address and repository to connect to.",
-+ },
-+ {
-+ .name = PBS_OPT_SNAPSHOT,
-+ .type = QEMU_OPT_STRING,
-+ .help = "The snapshot to read.",
-+ },
-+ {
-+ .name = PBS_OPT_ARCHIVE,
-+ .type = QEMU_OPT_STRING,
-+ .help = "Which archive within the snapshot should be accessed.",
-+ },
-+ {
-+ .name = PBS_OPT_PASSWORD,
-+ .type = QEMU_OPT_STRING,
-+ .help = "Server password. Can be passed as env var 'PBS_PASSWORD'.",
-+ },
-+ {
-+ .name = PBS_OPT_FINGERPRINT,
-+ .type = QEMU_OPT_STRING,
-+ .help = "Server fingerprint. Can be passed as env var 'PBS_FINGERPRINT'.",
-+ },
-+ {
-+ .name = PBS_OPT_ENCRYPTION_PASSWORD,
-+ .type = QEMU_OPT_STRING,
-+ .help = "Optional: Key password. Can be passed as env var 'PBS_ENCRYPTION_PASSWORD'.",
-+ },
-+ {
-+ .name = PBS_OPT_KEYFILE,
-+ .type = QEMU_OPT_STRING,
-+ .help = "Optional: The path to the keyfile to use.",
-+ },
-+ { /* end of list */ }
-+ },
-+};
-+
-+
-+// filename format:
-+// pbs:repository=<repo>,snapshot=<snap>,password=<pw>,key_password=<kpw>,fingerprint=<fp>,archive=<archive>
-+static void pbs_parse_filename(const char *filename, QDict *options,
-+ Error **errp)
-+{
-+
-+ if (!strstart(filename, "pbs:", &filename)) {
-+ if (errp) error_setg(errp, "pbs_parse_filename failed - missing 'pbs:' prefix");
-+ }
-+
-+
-+ QemuOpts *opts = qemu_opts_parse_noisily(&runtime_opts, filename, false);
-+ if (!opts) {
-+ if (errp) error_setg(errp, "pbs_parse_filename failed");
-+ return;
-+ }
-+
-+ qemu_opts_to_qdict(opts, options);
-+
-+ qemu_opts_del(opts);
-+}
-+
-+static int pbs_open(BlockDriverState *bs, QDict *options, int flags,
-+ Error **errp)
-+{
-+ QemuOpts *opts;
-+ BDRVPBSState *s = bs->opaque;
-+ char *pbs_error = NULL;
-+
-+ opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
-+ qemu_opts_absorb_qdict(opts, options, &error_abort);
-+
-+ s->repository = g_strdup(qemu_opt_get(opts, PBS_OPT_REPOSITORY));
-+ s->snapshot = g_strdup(qemu_opt_get(opts, PBS_OPT_SNAPSHOT));
-+ s->archive = g_strdup(qemu_opt_get(opts, PBS_OPT_ARCHIVE));
-+ const char *keyfile = qemu_opt_get(opts, PBS_OPT_KEYFILE);
-+ const char *password = qemu_opt_get(opts, PBS_OPT_PASSWORD);
-+ const char *fingerprint = qemu_opt_get(opts, PBS_OPT_FINGERPRINT);
-+ const char *key_password = qemu_opt_get(opts, PBS_OPT_ENCRYPTION_PASSWORD);
-+
-+ if (!password) {
-+ password = getenv("PBS_PASSWORD");
-+ }
-+ if (!fingerprint) {
-+ fingerprint = getenv("PBS_FINGERPRINT");
-+ }
-+ if (!key_password) {
-+ key_password = getenv("PBS_ENCRYPTION_PASSWORD");
-+ }
-+
-+ /* connect to PBS server in read mode */
-+ s->conn = proxmox_restore_new(s->repository, s->snapshot, password,
-+ keyfile, key_password, fingerprint, &pbs_error);
-+
-+ /* invalidates qemu_opt_get char pointers from above */
-+ qemu_opts_del(opts);
-+
-+ if (!s->conn) {
-+ if (pbs_error && errp) error_setg(errp, "PBS restore_new failed: %s", pbs_error);
-+ if (pbs_error) proxmox_backup_free_error(pbs_error);
-+ return -ENOMEM;
-+ }
-+
-+ int ret = proxmox_restore_connect(s->conn, &pbs_error);
-+ if (ret < 0) {
-+ if (pbs_error && errp) error_setg(errp, "PBS connect failed: %s", pbs_error);
-+ if (pbs_error) proxmox_backup_free_error(pbs_error);
-+ return -ECONNREFUSED;
-+ }
-+
-+ /* acquire handle and length */
-+ s->aid = proxmox_restore_open_image(s->conn, s->archive, &pbs_error);
-+ if (s->aid < 0) {
-+ if (pbs_error && errp) error_setg(errp, "PBS open_image failed: %s", pbs_error);
-+ if (pbs_error) proxmox_backup_free_error(pbs_error);
-+ return -ENODEV;
-+ }
-+ s->length = proxmox_restore_get_image_length(s->conn, s->aid, &pbs_error);
-+ if (s->length < 0) {
-+ if (pbs_error && errp) error_setg(errp, "PBS get_image_length failed: %s", pbs_error);
-+ if (pbs_error) proxmox_backup_free_error(pbs_error);
-+ return -EINVAL;
-+ }
-+
-+ return 0;
-+}
-+
-+static int pbs_file_open(BlockDriverState *bs, QDict *options, int flags,
-+ Error **errp)
-+{
-+ return pbs_open(bs, options, flags, errp);
-+}
-+
-+static void pbs_close(BlockDriverState *bs) {
-+ BDRVPBSState *s = bs->opaque;
-+ g_free(s->repository);
-+ g_free(s->snapshot);
-+ g_free(s->archive);
-+ proxmox_restore_disconnect(s->conn);
-+}
-+
-+static int64_t pbs_getlength(BlockDriverState *bs)
-+{
-+ BDRVPBSState *s = bs->opaque;
-+ return s->length;
-+}
-+
-+typedef struct ReadCallbackData {
-+ Coroutine *co;
-+ AioContext *ctx;
-+} ReadCallbackData;
-+
-+static void read_callback(void *callback_data)
-+{
-+ ReadCallbackData *rcb = callback_data;
-+ aio_co_schedule(rcb->ctx, rcb->co);
-+}
-+
-+static coroutine_fn int pbs_co_preadv(BlockDriverState *bs,
-+ uint64_t offset, uint64_t bytes,
-+ QEMUIOVector *qiov, int flags)
-+{
-+ BDRVPBSState *s = bs->opaque;
-+ int ret;
-+ char *pbs_error = NULL;
-+ uint8_t *buf = malloc(bytes);
-+
-+ ReadCallbackData rcb = {
-+ .co = qemu_coroutine_self(),
-+ .ctx = qemu_get_current_aio_context(),
-+ };
-+
-+ proxmox_restore_read_image_at_async(s->conn, s->aid, buf, offset, bytes,
-+ read_callback, (void *) &rcb, &ret, &pbs_error);
-+
-+ qemu_coroutine_yield();
-+
-+ if (ret < 0) {
-+ fprintf(stderr, "error during PBS read: %s\n", pbs_error ? pbs_error : "unknown error");
-+ if (pbs_error) proxmox_backup_free_error(pbs_error);
-+ return -EIO;
-+ }
-+
-+ qemu_iovec_from_buf(qiov, 0, buf, bytes);
-+ free(buf);
-+
-+ return ret;
-+}
-+
-+static coroutine_fn int pbs_co_pwritev(BlockDriverState *bs,
-+ uint64_t offset, uint64_t bytes,
-+ QEMUIOVector *qiov, int flags)
-+{
-+ fprintf(stderr, "pbs-bdrv: cannot write to backup file, make sure "
-+ "any attached disk devices are set to read-only!\n");
-+ return -EPERM;
-+}
-+
-+static void pbs_refresh_filename(BlockDriverState *bs)
-+{
-+ BDRVPBSState *s = bs->opaque;
-+ snprintf(bs->exact_filename, sizeof(bs->exact_filename), "%s/%s(%s)",
-+ s->repository, s->snapshot, s->archive);
-+}
-+
-+static const char *const pbs_strong_runtime_opts[] = {
-+ NULL
-+};
-+
-+static BlockDriver bdrv_pbs_co = {
-+ .format_name = "pbs",
-+ .protocol_name = "pbs",
-+ .instance_size = sizeof(BDRVPBSState),
-+
-+ .bdrv_parse_filename = pbs_parse_filename,
-+
-+ .bdrv_file_open = pbs_file_open,
-+ .bdrv_open = pbs_open,
-+ .bdrv_close = pbs_close,
-+ .bdrv_getlength = pbs_getlength,
-+
-+ .bdrv_co_preadv = pbs_co_preadv,
-+ .bdrv_co_pwritev = pbs_co_pwritev,
-+
-+ .bdrv_refresh_filename = pbs_refresh_filename,
-+ .strong_runtime_opts = pbs_strong_runtime_opts,
-+};
-+
-+static void bdrv_pbs_init(void)
-+{
-+ bdrv_register(&bdrv_pbs_co);
-+}
-+
-+block_init(bdrv_pbs_init);
-diff --git a/configure b/configure
-index 2acc4d1465..3fc80d0c2c 100755
---- a/configure
-+++ b/configure
-@@ -510,6 +510,7 @@ vvfat="yes"
- qed="yes"
- parallels="yes"
- sheepdog="yes"
-+pbs_bdrv="yes"
- libxml2=""
- debug_mutex="no"
- libpmem=""
-@@ -1576,6 +1577,10 @@ for opt do
- ;;
- --enable-sheepdog) sheepdog="yes"
- ;;
-+ --disable-pbs-bdrv) pbs_bdrv="no"
-+ ;;
-+ --enable-pbs-bdrv) pbs_bdrv="yes"
-+ ;;
- --disable-vhost-user) vhost_user="no"
- ;;
- --enable-vhost-user) vhost_user="yes"
-@@ -1936,6 +1941,7 @@ disabled with --disable-FEATURE, default is enabled if available:
- qed qed image format support
- parallels parallels image format support
- sheepdog sheepdog block driver support
-+ pbs-bdrv Proxmox backup server read-only block driver support
- crypto-afalg Linux AF_ALG crypto backend driver
- capstone capstone disassembler support
- debug-mutex mutex debugging support
-@@ -7009,6 +7015,7 @@ echo "vvfat support $vvfat"
- echo "qed support $qed"
- echo "parallels support $parallels"
- echo "sheepdog support $sheepdog"
-+echo "pbs-bdrv support $pbs_bdrv"
- echo "capstone $capstone"
- echo "libpmem support $libpmem"
- echo "libdaxctl support $libdaxctl"
-@@ -7885,6 +7892,9 @@ fi
- if test "$sheepdog" = "yes" ; then
- echo "CONFIG_SHEEPDOG=y" >> $config_host_mak
- fi
-+if test "$pbs_bdrv" = "yes" ; then
-+ echo "CONFIG_PBS_BDRV=y" >> $config_host_mak
-+fi
- if test "$pty_h" = "yes" ; then
- echo "HAVE_PTY_H=y" >> $config_host_mak
- fi
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index a177fea6cd..f782c2cf96 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -2951,7 +2951,7 @@
- 'luks', 'nbd', 'nfs', 'null-aio', 'null-co', 'nvme', 'parallels',
- 'qcow', 'qcow2', 'qed', 'quorum', 'raw', 'rbd',
- { 'name': 'replication', 'if': 'defined(CONFIG_REPLICATION)' },
-- 'sheepdog',
-+ 'sheepdog', 'pbs',
- 'ssh', 'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
-
- ##
-@@ -3015,6 +3015,17 @@
- { 'struct': 'BlockdevOptionsNull',
- 'data': { '*size': 'int', '*latency-ns': 'uint64', '*read-zeroes': 'bool' } }
-
-+##
-+# @BlockdevOptionsPbs:
-+#
-+# Driver specific block device options for the PBS backend.
-+#
-+##
-+{ 'struct': 'BlockdevOptionsPbs',
-+ 'data': { 'repository': 'str', 'snapshot': 'str', 'archive': 'str',
-+ '*keyfile': 'str', '*password': 'str', '*fingerprint': 'str',
-+ '*key_password': 'str' } }
-+
- ##
- # @BlockdevOptionsNVMe:
- #
-@@ -4121,6 +4132,7 @@
- 'nfs': 'BlockdevOptionsNfs',
- 'null-aio': 'BlockdevOptionsNull',
- 'null-co': 'BlockdevOptionsNull',
-+ 'pbs': 'BlockdevOptionsPbs',
- 'nvme': 'BlockdevOptionsNVMe',
- 'parallels': 'BlockdevOptionsGenericFormat',
- 'qcow2': 'BlockdevOptionsQcow2',
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Wed, 8 Jul 2020 11:57:53 +0200
+Subject: [PATCH] PVE: add query_proxmox_support QMP command
+
+Generic interface for future use, currently used for PBS dirty-bitmap
+backup support.
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
+---
+ pve-backup.c | 7 +++++++
+ qapi/block-core.json | 22 ++++++++++++++++++++++
+ 2 files changed, 29 insertions(+)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index bfb648d6b5..2539ae1520 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -1051,3 +1051,10 @@ BackupStatus *qmp_query_backup(Error **errp)
+
+ return info;
+ }
++
++ProxmoxSupportStatus *qmp_query_proxmox_support(Error **errp)
++{
++ ProxmoxSupportStatus *ret = g_malloc0(sizeof(*ret));
++ ret->pbs_dirty_bitmap = true;
++ return ret;
++}
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index f782c2cf96..6dd5e35473 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -877,6 +877,28 @@
+ ##
+ { 'command': 'backup-cancel' }
+
++##
++# @ProxmoxSupportStatus:
++#
++# Contains info about supported features added by Proxmox.
++#
++# @pbs-dirty-bitmap: True if dirty-bitmap-incremental backups to PBS are
++# supported.
++#
++##
++{ 'struct': 'ProxmoxSupportStatus',
++ 'data': { 'pbs-dirty-bitmap': 'bool' } }
++
++##
++# @query-proxmox-support:
++#
++# Returns information about supported features added by Proxmox.
++#
++# Returns: @ProxmoxSupportStatus
++#
++##
++{ 'command': 'query-proxmox-support', 'returns': 'ProxmoxSupportStatus' }
++
+ ##
+ # @BlockDeviceTimedStats:
+ #
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Wed, 8 Jul 2020 11:57:53 +0200
-Subject: [PATCH] PVE: add query_proxmox_support QMP command
-
-Generic interface for future use, currently used for PBS dirty-bitmap
-backup support.
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
-Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
----
- pve-backup.c | 7 +++++++
- qapi/block-core.json | 22 ++++++++++++++++++++++
- 2 files changed, 29 insertions(+)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index 343035b5c9..b0e7b51eef 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -1055,3 +1055,10 @@ BackupStatus *qmp_query_backup(Error **errp)
-
- return info;
- }
-+
-+ProxmoxSupportStatus *qmp_query_proxmox_support(Error **errp)
-+{
-+ ProxmoxSupportStatus *ret = g_malloc0(sizeof(*ret));
-+ ret->pbs_dirty_bitmap = true;
-+ return ret;
-+}
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index f782c2cf96..6dd5e35473 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -877,6 +877,28 @@
- ##
- { 'command': 'backup-cancel' }
-
-+##
-+# @ProxmoxSupportStatus:
-+#
-+# Contains info about supported features added by Proxmox.
-+#
-+# @pbs-dirty-bitmap: True if dirty-bitmap-incremental backups to PBS are
-+# supported.
-+#
-+##
-+{ 'struct': 'ProxmoxSupportStatus',
-+ 'data': { 'pbs-dirty-bitmap': 'bool' } }
-+
-+##
-+# @query-proxmox-support:
-+#
-+# Returns information about supported features added by Proxmox.
-+#
-+# Returns: @ProxmoxSupportStatus
-+#
-+##
-+{ 'command': 'query-proxmox-support', 'returns': 'ProxmoxSupportStatus' }
-+
- ##
- # @BlockDeviceTimedStats:
- #
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Wolfgang Bumiller <w.bumiller@proxmox.com>
+Date: Fri, 10 Jul 2020 13:22:35 +0200
+Subject: [PATCH] pbs: fix missing crypt and compress parameters
+
+Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>
+---
+ pve-backup.c | 8 ++++++--
+ 1 file changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 2539ae1520..0e293a4f5e 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -958,6 +958,8 @@ UuidInfo *qmp_backup(
+ .backup_file = backup_file,
+ .has_password = has_password,
+ .password = password,
++ .has_keyfile = has_keyfile,
++ .keyfile = keyfile,
+ .has_key_password = has_key_password,
+ .key_password = key_password,
+ .has_fingerprint = has_fingerprint,
+@@ -968,6 +970,10 @@ UuidInfo *qmp_backup(
+ .backup_time = backup_time,
+ .has_use_dirty_bitmap = has_use_dirty_bitmap,
+ .use_dirty_bitmap = use_dirty_bitmap,
++ .has_compress = has_compress,
++ .compress = compress,
++ .has_encrypt = has_encrypt,
++ .encrypt = encrypt,
+ .has_format = has_format,
+ .format = format,
+ .has_config_file = has_config_file,
+@@ -976,8 +982,6 @@ UuidInfo *qmp_backup(
+ .firewall_file = firewall_file,
+ .has_devlist = has_devlist,
+ .devlist = devlist,
+- .has_compress = has_compress,
+- .has_encrypt = has_encrypt,
+ .has_speed = has_speed,
+ .speed = speed,
+ .errp = errp,
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Wed, 19 Aug 2020 12:33:17 +0200
+Subject: [PATCH] PVE: handle PBS write callback with big blocks correctly
+
+Under certain conditions QEMU will push more than the given blocksize
+into the callback at once. Handle it like VMA does, by iterating the
+data until all is written.
+
+The block size is stored per backup device to be used in the callback.
+This avoids relying on PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE, in case it is
+made configurable in the future.
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+---
+ pve-backup.c | 30 ++++++++++++++++++++++--------
+ 1 file changed, 22 insertions(+), 8 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 0e293a4f5e..8999692418 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -67,6 +67,7 @@ opts_init(pvebackup_init);
+ typedef struct PVEBackupDevInfo {
+ BlockDriverState *bs;
+ size_t size;
++ uint64_t block_size;
+ uint8_t dev_id;
+ bool completed;
+ char targetfile[PATH_MAX];
+@@ -147,17 +148,28 @@ pvebackup_co_dump_pbs_cb(
+ return -1;
+ }
+
+- pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
+- qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
++ uint64_t transferred = 0;
++ uint64_t reused = 0;
++ while (transferred < size) {
++ uint64_t left = size - transferred;
++ uint64_t to_transfer = left < di->block_size ? left : di->block_size;
+
+- if (pbs_res < 0) {
+- pvebackup_propagate_error(local_err);
+- return pbs_res;
+- } else {
+- size_t reused = (pbs_res == 0) ? size : 0;
+- pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
++ pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id,
++ buf ? buf + transferred : NULL, start + transferred, to_transfer, &local_err);
++ transferred += to_transfer;
++
++ if (pbs_res < 0) {
++ pvebackup_propagate_error(local_err);
++ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
++ return pbs_res;
++ }
++
++ reused += pbs_res == 0 ? to_transfer : 0;
+ }
+
++ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
++ pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
++
+ return size;
+ }
+
+@@ -726,6 +738,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+ l = g_list_next(l);
+
++ di->block_size = dump_cb_block_size;
++
+ const char *devname = bdrv_get_device_name(di->bs);
+
+ BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Wolfgang Bumiller <w.bumiller@proxmox.com>
-Date: Fri, 10 Jul 2020 13:22:35 +0200
-Subject: [PATCH] pbs: fix missing crypt and compress parameters
-
-Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>
----
- pve-backup.c | 8 ++++++--
- 1 file changed, 6 insertions(+), 2 deletions(-)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index b0e7b51eef..77eb475563 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -962,6 +962,8 @@ UuidInfo *qmp_backup(
- .backup_file = backup_file,
- .has_password = has_password,
- .password = password,
-+ .has_keyfile = has_keyfile,
-+ .keyfile = keyfile,
- .has_key_password = has_key_password,
- .key_password = key_password,
- .has_fingerprint = has_fingerprint,
-@@ -972,6 +974,10 @@ UuidInfo *qmp_backup(
- .backup_time = backup_time,
- .has_use_dirty_bitmap = has_use_dirty_bitmap,
- .use_dirty_bitmap = use_dirty_bitmap,
-+ .has_compress = has_compress,
-+ .compress = compress,
-+ .has_encrypt = has_encrypt,
-+ .encrypt = encrypt,
- .has_format = has_format,
- .format = format,
- .has_config_file = has_config_file,
-@@ -980,8 +986,6 @@ UuidInfo *qmp_backup(
- .firewall_file = firewall_file,
- .has_devlist = has_devlist,
- .devlist = devlist,
-- .has_compress = has_compress,
-- .has_encrypt = has_encrypt,
- .has_speed = has_speed,
- .speed = speed,
- .errp = errp,
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Thu, 13 Aug 2020 13:50:27 +0200
+Subject: [PATCH] PVE: add zero block handling to PBS dump callback
+
+Both the PBS and VMA dump callbacks assume that a NULL pointer can be
+passed as *pbuf, but that never happens, as backup-dump.c calls this
+function with contents of an iovec.
+
+So first, remove that assumption and add an 'assert' to verify.
+
+Secondly, while the vma-writer already does the buffer_is_zero check
+internally, for PBS we relied on that non-existant behaviour for zero
+chunks, so do the buffer_is_zero check manually and pass NULL to the
+rust lib in case it is true.
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+---
+ pve-backup.c | 14 +++++++++-----
+ 1 file changed, 9 insertions(+), 5 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 8999692418..562fcc20f7 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -8,6 +8,7 @@
+ #include "block/blockjob.h"
+ #include "qapi/qapi-commands-block.h"
+ #include "qapi/qmp/qerror.h"
++#include "qemu/cutils.h"
+
+ /* PVE backup state and related function */
+
+@@ -136,10 +137,13 @@ pvebackup_co_dump_pbs_cb(
+ PVEBackupDevInfo *di = opaque;
+
+ assert(backup_state.pbs);
++ assert(buf);
+
+ Error *local_err = NULL;
+ int pbs_res = -1;
+
++ bool is_zero_block = size == di->block_size && buffer_is_zero(buf, size);
++
+ qemu_co_mutex_lock(&backup_state.dump_callback_mutex);
+
+ // avoid deadlock if job is cancelled
+@@ -155,7 +159,8 @@ pvebackup_co_dump_pbs_cb(
+ uint64_t to_transfer = left < di->block_size ? left : di->block_size;
+
+ pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id,
+- buf ? buf + transferred : NULL, start + transferred, to_transfer, &local_err);
++ is_zero_block ? NULL : buf + transferred, start + transferred,
++ to_transfer, &local_err);
+ transferred += to_transfer;
+
+ if (pbs_res < 0) {
+@@ -168,7 +173,7 @@ pvebackup_co_dump_pbs_cb(
+ }
+
+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
+- pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
++ pvebackup_add_transfered_bytes(size, is_zero_block ? size : 0, reused);
+
+ return size;
+ }
+@@ -190,6 +195,7 @@ pvebackup_co_dump_vma_cb(
+ int ret = -1;
+
+ assert(backup_state.vmaw);
++ assert(buf);
+
+ uint64_t remaining = size;
+
+@@ -216,9 +222,7 @@ pvebackup_co_dump_vma_cb(
+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
+
+ ++cluster_num;
+- if (buf) {
+- buf += VMA_CLUSTER_SIZE;
+- }
++ buf += VMA_CLUSTER_SIZE;
+ if (ret < 0) {
+ Error *local_err = NULL;
+ vma_writer_error_propagate(backup_state.vmaw, &local_err);
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Wed, 19 Aug 2020 12:33:17 +0200
-Subject: [PATCH] PVE: handle PBS write callback with big blocks correctly
-
-Under certain conditions QEMU will push more than the given blocksize
-into the callback at once. Handle it like VMA does, by iterating the
-data until all is written.
-
-The block size is stored per backup device to be used in the callback.
-This avoids relying on PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE, in case it is
-made configurable in the future.
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
----
- pve-backup.c | 30 ++++++++++++++++++++++--------
- 1 file changed, 22 insertions(+), 8 deletions(-)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index 77eb475563..40d8136f1a 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -67,6 +67,7 @@ opts_init(pvebackup_init);
- typedef struct PVEBackupDevInfo {
- BlockDriverState *bs;
- size_t size;
-+ uint64_t block_size;
- uint8_t dev_id;
- bool completed;
- char targetfile[PATH_MAX];
-@@ -147,17 +148,28 @@ pvebackup_co_dump_pbs_cb(
- return -1;
- }
-
-- pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id, buf, start, size, &local_err);
-- qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-+ uint64_t transferred = 0;
-+ uint64_t reused = 0;
-+ while (transferred < size) {
-+ uint64_t left = size - transferred;
-+ uint64_t to_transfer = left < di->block_size ? left : di->block_size;
-
-- if (pbs_res < 0) {
-- pvebackup_propagate_error(local_err);
-- return pbs_res;
-- } else {
-- size_t reused = (pbs_res == 0) ? size : 0;
-- pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
-+ pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id,
-+ buf ? buf + transferred : NULL, start + transferred, to_transfer, &local_err);
-+ transferred += to_transfer;
-+
-+ if (pbs_res < 0) {
-+ pvebackup_propagate_error(local_err);
-+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-+ return pbs_res;
-+ }
-+
-+ reused += pbs_res == 0 ? to_transfer : 0;
- }
-
-+ qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-+ pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
-+
- return size;
- }
-
-@@ -730,6 +742,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
- l = g_list_next(l);
-
-+ di->block_size = dump_cb_block_size;
-+
- const char *devname = bdrv_get_device_name(di->bs);
-
- BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Wed, 19 Aug 2020 17:02:00 +0200
+Subject: [PATCH] PVE: add query-pbs-bitmap-info QMP call
+
+Returns advanced information about dirty bitmaps used (or not used) for
+the latest PBS backup.
+
+Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
+---
+ monitor/hmp-cmds.c | 28 ++++++-----
+ pve-backup.c | 117 ++++++++++++++++++++++++++++++++-----------
+ qapi/block-core.json | 57 ++++++++++++++++++++-
+ 3 files changed, 159 insertions(+), 43 deletions(-)
+
+diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
+index 3ff014d32a..c3227a1498 100644
+--- a/monitor/hmp-cmds.c
++++ b/monitor/hmp-cmds.c
+@@ -195,6 +195,7 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
+ void hmp_info_backup(Monitor *mon, const QDict *qdict)
+ {
+ BackupStatus *info;
++ PBSBitmapInfoList *bitmap_info;
+
+ info = qmp_query_backup(NULL);
+
+@@ -225,26 +226,29 @@ void hmp_info_backup(Monitor *mon, const QDict *qdict)
+ // this should not happen normally
+ monitor_printf(mon, "Total size: %d\n", 0);
+ } else {
+- bool incremental = false;
+ size_t total_or_dirty = info->total;
+- if (info->has_transferred) {
+- if (info->has_dirty && info->dirty) {
+- if (info->dirty < info->total) {
+- total_or_dirty = info->dirty;
+- incremental = true;
+- }
+- }
++ bitmap_info = qmp_query_pbs_bitmap_info(NULL);
++
++ while (bitmap_info) {
++ monitor_printf(mon, "Drive %s:\n",
++ bitmap_info->value->drive);
++ monitor_printf(mon, " bitmap action: %s\n",
++ PBSBitmapAction_str(bitmap_info->value->action));
++ monitor_printf(mon, " size: %zd\n",
++ bitmap_info->value->size);
++ monitor_printf(mon, " dirty: %zd\n",
++ bitmap_info->value->dirty);
++ bitmap_info = bitmap_info->next;
+ }
+
+- int per = (info->transferred * 100)/total_or_dirty;
+-
+- monitor_printf(mon, "Backup mode: %s\n", incremental ? "incremental" : "full");
++ qapi_free_PBSBitmapInfoList(bitmap_info);
+
+ int zero_per = (info->has_zero_bytes && info->zero_bytes) ?
+ (info->zero_bytes * 100)/info->total : 0;
+ monitor_printf(mon, "Total size: %zd\n", info->total);
++ int trans_per = (info->transferred * 100)/total_or_dirty;
+ monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
+- info->transferred, per);
++ info->transferred, trans_per);
+ monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
+ info->zero_bytes, zero_per);
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 562fcc20f7..04c21c80aa 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -46,6 +46,7 @@ static struct PVEBackupState {
+ size_t transferred;
+ size_t reused;
+ size_t zero_bytes;
++ GList *bitmap_list;
+ } stat;
+ int64_t speed;
+ VmaWriter *vmaw;
+@@ -670,7 +671,6 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ }
+
+ size_t total = 0;
+- size_t dirty = 0;
+
+ l = di_list;
+ while (l) {
+@@ -691,18 +691,33 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+
+ uuid_generate(uuid);
+
++ qemu_mutex_lock(&backup_state.stat.lock);
++ backup_state.stat.reused = 0;
++
++ /* clear previous backup's bitmap_list */
++ if (backup_state.stat.bitmap_list) {
++ GList *bl = backup_state.stat.bitmap_list;
++ while (bl) {
++ g_free(((PBSBitmapInfo *)bl->data)->drive);
++ g_free(bl->data);
++ bl = g_list_next(bl);
++ }
++ g_list_free(backup_state.stat.bitmap_list);
++ backup_state.stat.bitmap_list = NULL;
++ }
++
+ if (format == BACKUP_FORMAT_PBS) {
+ if (!task->has_password) {
+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'password'");
+- goto err;
++ goto err_mutex;
+ }
+ if (!task->has_backup_id) {
+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-id'");
+- goto err;
++ goto err_mutex;
+ }
+ if (!task->has_backup_time) {
+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-time'");
+- goto err;
++ goto err_mutex;
+ }
+
+ int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
+@@ -729,12 +744,12 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
+ "proxmox_backup_new failed: %s", pbs_err);
+ proxmox_backup_free_error(pbs_err);
+- goto err;
++ goto err_mutex;
+ }
+
+ int connect_result = proxmox_backup_co_connect(pbs, task->errp);
+ if (connect_result < 0)
+- goto err;
++ goto err_mutex;
+
+ /* register all devices */
+ l = di_list;
+@@ -745,6 +760,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ di->block_size = dump_cb_block_size;
+
+ const char *devname = bdrv_get_device_name(di->bs);
++ PBSBitmapAction action = PBS_BITMAP_ACTION_NOT_USED;
++ size_t dirty = di->size;
+
+ BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
+ bool expect_only_dirty = false;
+@@ -753,49 +770,59 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ if (bitmap == NULL) {
+ bitmap = bdrv_create_dirty_bitmap(di->bs, dump_cb_block_size, PBS_BITMAP_NAME, task->errp);
+ if (!bitmap) {
+- goto err;
++ goto err_mutex;
+ }
++ action = PBS_BITMAP_ACTION_NEW;
+ } else {
+ expect_only_dirty = proxmox_backup_check_incremental(pbs, devname, di->size) != 0;
+ }
+
+ if (expect_only_dirty) {
+- dirty += bdrv_get_dirty_count(bitmap);
++ /* track clean chunks as reused */
++ dirty = MIN(bdrv_get_dirty_count(bitmap), di->size);
++ backup_state.stat.reused += di->size - dirty;
++ action = PBS_BITMAP_ACTION_USED;
+ } else {
+ /* mark entire bitmap as dirty to make full backup */
+ bdrv_set_dirty_bitmap(bitmap, 0, di->size);
+- dirty += di->size;
++ if (action != PBS_BITMAP_ACTION_NEW) {
++ action = PBS_BITMAP_ACTION_INVALID;
++ }
+ }
+ di->bitmap = bitmap;
+ } else {
+- dirty += di->size;
+-
+ /* after a full backup the old dirty bitmap is invalid anyway */
+ if (bitmap != NULL) {
+ bdrv_release_dirty_bitmap(bitmap);
++ action = PBS_BITMAP_ACTION_NOT_USED_REMOVED;
+ }
+ }
+
+ int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, expect_only_dirty, task->errp);
+ if (dev_id < 0) {
+- goto err;
++ goto err_mutex;
+ }
+
+ if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_pbs_cb, di, task->errp))) {
+- goto err;
++ goto err_mutex;
+ }
+
+ di->dev_id = dev_id;
++
++ PBSBitmapInfo *info = g_malloc(sizeof(*info));
++ info->drive = g_strdup(devname);
++ info->action = action;
++ info->size = di->size;
++ info->dirty = dirty;
++ backup_state.stat.bitmap_list = g_list_append(backup_state.stat.bitmap_list, info);
+ }
+ } else if (format == BACKUP_FORMAT_VMA) {
+- dirty = total;
+-
+ vmaw = vma_writer_create(task->backup_file, uuid, &local_err);
+ if (!vmaw) {
+ if (local_err) {
+ error_propagate(task->errp, local_err);
+ }
+- goto err;
++ goto err_mutex;
+ }
+
+ /* register all devices for vma writer */
+@@ -805,7 +832,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ l = g_list_next(l);
+
+ if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_vma_cb, di, task->errp))) {
+- goto err;
++ goto err_mutex;
+ }
+
+ const char *devname = bdrv_get_device_name(di->bs);
+@@ -813,16 +840,14 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ if (di->dev_id <= 0) {
+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
+ "register_stream failed");
+- goto err;
++ goto err_mutex;
+ }
+ }
+ } else if (format == BACKUP_FORMAT_DIR) {
+- dirty = total;
+-
+ if (mkdir(task->backup_file, 0640) != 0) {
+ error_setg_errno(task->errp, errno, "can't create directory '%s'\n",
+ task->backup_file);
+- goto err;
++ goto err_mutex;
+ }
+ backup_dir = task->backup_file;
+
+@@ -839,18 +864,18 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ di->size, flags, false, &local_err);
+ if (local_err) {
+ error_propagate(task->errp, local_err);
+- goto err;
++ goto err_mutex;
+ }
+
+ di->target = bdrv_open(di->targetfile, NULL, NULL, flags, &local_err);
+ if (!di->target) {
+ error_propagate(task->errp, local_err);
+- goto err;
++ goto err_mutex;
+ }
+ }
+ } else {
+ error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
+- goto err;
++ goto err_mutex;
+ }
+
+
+@@ -858,7 +883,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ if (task->has_config_file) {
+ if (pvebackup_co_add_config(task->config_file, config_name, format, backup_dir,
+ vmaw, pbs, task->errp) != 0) {
+- goto err;
++ goto err_mutex;
+ }
+ }
+
+@@ -866,12 +891,11 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ if (task->has_firewall_file) {
+ if (pvebackup_co_add_config(task->firewall_file, firewall_name, format, backup_dir,
+ vmaw, pbs, task->errp) != 0) {
+- goto err;
++ goto err_mutex;
+ }
+ }
+ /* initialize global backup_state now */
+-
+- qemu_mutex_lock(&backup_state.stat.lock);
++ /* note: 'reused' and 'bitmap_list' are initialized earlier */
+
+ if (backup_state.stat.error) {
+ error_free(backup_state.stat.error);
+@@ -891,10 +915,9 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ char *uuid_str = g_strdup(backup_state.stat.uuid_str);
+
+ backup_state.stat.total = total;
+- backup_state.stat.dirty = dirty;
++ backup_state.stat.dirty = total - backup_state.stat.reused;
+ backup_state.stat.transferred = 0;
+ backup_state.stat.zero_bytes = 0;
+- backup_state.stat.reused = format == BACKUP_FORMAT_PBS && dirty >= total ? 0 : total - dirty;
+
+ qemu_mutex_unlock(&backup_state.stat.lock);
+
+@@ -911,6 +934,9 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ task->result = uuid_info;
+ return;
+
++err_mutex:
++ qemu_mutex_unlock(&backup_state.stat.lock);
++
+ err:
+
+ l = di_list;
+@@ -1074,9 +1100,40 @@ BackupStatus *qmp_query_backup(Error **errp)
+ return info;
+ }
+
++PBSBitmapInfoList *qmp_query_pbs_bitmap_info(Error **errp)
++{
++ PBSBitmapInfoList *head = NULL, **p_next = &head;
++
++ qemu_mutex_lock(&backup_state.stat.lock);
++
++ GList *l = backup_state.stat.bitmap_list;
++ while (l) {
++ PBSBitmapInfo *info = (PBSBitmapInfo *)l->data;
++ l = g_list_next(l);
++
++ /* clone bitmap info to avoid auto free after QMP marshalling */
++ PBSBitmapInfo *info_ret = g_malloc0(sizeof(*info_ret));
++ info_ret->drive = g_strdup(info->drive);
++ info_ret->action = info->action;
++ info_ret->size = info->size;
++ info_ret->dirty = info->dirty;
++
++ PBSBitmapInfoList *info_list = g_malloc0(sizeof(*info_list));
++ info_list->value = info_ret;
++
++ *p_next = info_list;
++ p_next = &info_list->next;
++ }
++
++ qemu_mutex_unlock(&backup_state.stat.lock);
++
++ return head;
++}
++
+ ProxmoxSupportStatus *qmp_query_proxmox_support(Error **errp)
+ {
+ ProxmoxSupportStatus *ret = g_malloc0(sizeof(*ret));
+ ret->pbs_dirty_bitmap = true;
++ ret->query_bitmap_info = true;
+ return ret;
+ }
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index 6dd5e35473..5fc42e87f3 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -885,9 +885,11 @@
+ # @pbs-dirty-bitmap: True if dirty-bitmap-incremental backups to PBS are
+ # supported.
+ #
++# @query-bitmap-info: True if the 'query-pbs-bitmap-info' QMP call is supported.
++#
+ ##
+ { 'struct': 'ProxmoxSupportStatus',
+- 'data': { 'pbs-dirty-bitmap': 'bool' } }
++ 'data': { 'pbs-dirty-bitmap': 'bool', 'query-bitmap-info': 'bool' } }
+
+ ##
+ # @query-proxmox-support:
+@@ -899,6 +901,59 @@
+ ##
+ { 'command': 'query-proxmox-support', 'returns': 'ProxmoxSupportStatus' }
+
++##
++# @PBSBitmapAction:
++#
++# An action taken on a dirty-bitmap when a backup job was started.
++#
++# @not-used: Bitmap mode was not enabled.
++#
++# @not-used-removed: Bitmap mode was not enabled, but a bitmap from a
++# previous backup still existed and was removed.
++#
++# @new: A new bitmap was attached to the drive for this backup.
++#
++# @used: An existing bitmap will be used to only backup changed data.
++#
++# @invalid: A bitmap existed, but had to be cleared since it's associated
++# base snapshot did not match the base given for the current job or
++# the crypt mode has changed.
++#
++##
++{ 'enum': 'PBSBitmapAction',
++ 'data': ['not-used', 'not-used-removed', 'new', 'used', 'invalid'] }
++
++##
++# @PBSBitmapInfo:
++#
++# Contains information about dirty bitmaps used for each drive in a PBS backup.
++#
++# @drive: The underlying drive.
++#
++# @action: The action that was taken when the backup started.
++#
++# @size: The total size of the drive.
++#
++# @dirty: How much of the drive is considered dirty and will be backed up,
++# or 'size' if everything will be.
++#
++##
++{ 'struct': 'PBSBitmapInfo',
++ 'data': { 'drive': 'str', 'action': 'PBSBitmapAction', 'size': 'int',
++ 'dirty': 'int' } }
++
++##
++# @query-pbs-bitmap-info:
++#
++# Returns information about dirty bitmaps used on the most recently started
++# backup. Returns nothing when the last backup was not using PBS or if no
++# backup occured in this session.
++#
++# Returns: @PBSBitmapInfo
++#
++##
++{ 'command': 'query-pbs-bitmap-info', 'returns': ['PBSBitmapInfo'] }
++
+ ##
+ # @BlockDeviceTimedStats:
+ #
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Thu, 13 Aug 2020 13:50:27 +0200
-Subject: [PATCH] PVE: add zero block handling to PBS dump callback
-
-Both the PBS and VMA dump callbacks assume that a NULL pointer can be
-passed as *pbuf, but that never happens, as backup-dump.c calls this
-function with contents of an iovec.
-
-So first, remove that assumption and add an 'assert' to verify.
-
-Secondly, while the vma-writer already does the buffer_is_zero check
-internally, for PBS we relied on that non-existant behaviour for zero
-chunks, so do the buffer_is_zero check manually and pass NULL to the
-rust lib in case it is true.
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
----
- pve-backup.c | 14 +++++++++-----
- 1 file changed, 9 insertions(+), 5 deletions(-)
-
-diff --git a/pve-backup.c b/pve-backup.c
-index 40d8136f1a..7c99554514 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -8,6 +8,7 @@
- #include "block/blockjob.h"
- #include "qapi/qapi-commands-block.h"
- #include "qapi/qmp/qerror.h"
-+#include "qemu/cutils.h"
-
- /* PVE backup state and related function */
-
-@@ -136,10 +137,13 @@ pvebackup_co_dump_pbs_cb(
- PVEBackupDevInfo *di = opaque;
-
- assert(backup_state.pbs);
-+ assert(buf);
-
- Error *local_err = NULL;
- int pbs_res = -1;
-
-+ bool is_zero_block = size == di->block_size && buffer_is_zero(buf, size);
-+
- qemu_co_mutex_lock(&backup_state.dump_callback_mutex);
-
- // avoid deadlock if job is cancelled
-@@ -155,7 +159,8 @@ pvebackup_co_dump_pbs_cb(
- uint64_t to_transfer = left < di->block_size ? left : di->block_size;
-
- pbs_res = proxmox_backup_co_write_data(backup_state.pbs, di->dev_id,
-- buf ? buf + transferred : NULL, start + transferred, to_transfer, &local_err);
-+ is_zero_block ? NULL : buf + transferred, start + transferred,
-+ to_transfer, &local_err);
- transferred += to_transfer;
-
- if (pbs_res < 0) {
-@@ -168,7 +173,7 @@ pvebackup_co_dump_pbs_cb(
- }
-
- qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-- pvebackup_add_transfered_bytes(size, !buf ? size : 0, reused);
-+ pvebackup_add_transfered_bytes(size, is_zero_block ? size : 0, reused);
-
- return size;
- }
-@@ -190,6 +195,7 @@ pvebackup_co_dump_vma_cb(
- int ret = -1;
-
- assert(backup_state.vmaw);
-+ assert(buf);
-
- uint64_t remaining = size;
-
-@@ -216,9 +222,7 @@ pvebackup_co_dump_vma_cb(
- qemu_co_mutex_unlock(&backup_state.dump_callback_mutex);
-
- ++cluster_num;
-- if (buf) {
-- buf += VMA_CLUSTER_SIZE;
-- }
-+ buf += VMA_CLUSTER_SIZE;
- if (ret < 0) {
- Error *local_err = NULL;
- vma_writer_error_propagate(backup_state.vmaw, &local_err);
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Wed, 19 Aug 2020 17:02:00 +0200
-Subject: [PATCH] PVE: add query-pbs-bitmap-info QMP call
-
-Returns advanced information about dirty bitmaps used (or not used) for
-the latest PBS backup.
-
-Signed-off-by: Stefan Reiter <s.reiter@proxmox.com>
----
- monitor/hmp-cmds.c | 28 ++++++-----
- pve-backup.c | 117 ++++++++++++++++++++++++++++++++-----------
- qapi/block-core.json | 57 ++++++++++++++++++++-
- 3 files changed, 159 insertions(+), 43 deletions(-)
-
-diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
-index 3ff014d32a..c3227a1498 100644
---- a/monitor/hmp-cmds.c
-+++ b/monitor/hmp-cmds.c
-@@ -195,6 +195,7 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
- void hmp_info_backup(Monitor *mon, const QDict *qdict)
- {
- BackupStatus *info;
-+ PBSBitmapInfoList *bitmap_info;
-
- info = qmp_query_backup(NULL);
-
-@@ -225,26 +226,29 @@ void hmp_info_backup(Monitor *mon, const QDict *qdict)
- // this should not happen normally
- monitor_printf(mon, "Total size: %d\n", 0);
- } else {
-- bool incremental = false;
- size_t total_or_dirty = info->total;
-- if (info->has_transferred) {
-- if (info->has_dirty && info->dirty) {
-- if (info->dirty < info->total) {
-- total_or_dirty = info->dirty;
-- incremental = true;
-- }
-- }
-+ bitmap_info = qmp_query_pbs_bitmap_info(NULL);
-+
-+ while (bitmap_info) {
-+ monitor_printf(mon, "Drive %s:\n",
-+ bitmap_info->value->drive);
-+ monitor_printf(mon, " bitmap action: %s\n",
-+ PBSBitmapAction_str(bitmap_info->value->action));
-+ monitor_printf(mon, " size: %zd\n",
-+ bitmap_info->value->size);
-+ monitor_printf(mon, " dirty: %zd\n",
-+ bitmap_info->value->dirty);
-+ bitmap_info = bitmap_info->next;
- }
-
-- int per = (info->transferred * 100)/total_or_dirty;
--
-- monitor_printf(mon, "Backup mode: %s\n", incremental ? "incremental" : "full");
-+ qapi_free_PBSBitmapInfoList(bitmap_info);
-
- int zero_per = (info->has_zero_bytes && info->zero_bytes) ?
- (info->zero_bytes * 100)/info->total : 0;
- monitor_printf(mon, "Total size: %zd\n", info->total);
-+ int trans_per = (info->transferred * 100)/total_or_dirty;
- monitor_printf(mon, "Transferred bytes: %zd (%d%%)\n",
-- info->transferred, per);
-+ info->transferred, trans_per);
- monitor_printf(mon, "Zero bytes: %zd (%d%%)\n",
- info->zero_bytes, zero_per);
-
-diff --git a/pve-backup.c b/pve-backup.c
-index 7c99554514..c6d8a51406 100644
---- a/pve-backup.c
-+++ b/pve-backup.c
-@@ -46,6 +46,7 @@ static struct PVEBackupState {
- size_t transferred;
- size_t reused;
- size_t zero_bytes;
-+ GList *bitmap_list;
- } stat;
- int64_t speed;
- VmaWriter *vmaw;
-@@ -674,7 +675,6 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- }
-
- size_t total = 0;
-- size_t dirty = 0;
-
- l = di_list;
- while (l) {
-@@ -695,18 +695,33 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
-
- uuid_generate(uuid);
-
-+ qemu_mutex_lock(&backup_state.stat.lock);
-+ backup_state.stat.reused = 0;
-+
-+ /* clear previous backup's bitmap_list */
-+ if (backup_state.stat.bitmap_list) {
-+ GList *bl = backup_state.stat.bitmap_list;
-+ while (bl) {
-+ g_free(((PBSBitmapInfo *)bl->data)->drive);
-+ g_free(bl->data);
-+ bl = g_list_next(bl);
-+ }
-+ g_list_free(backup_state.stat.bitmap_list);
-+ backup_state.stat.bitmap_list = NULL;
-+ }
-+
- if (format == BACKUP_FORMAT_PBS) {
- if (!task->has_password) {
- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'password'");
-- goto err;
-+ goto err_mutex;
- }
- if (!task->has_backup_id) {
- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-id'");
-- goto err;
-+ goto err_mutex;
- }
- if (!task->has_backup_time) {
- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "missing parameter 'backup-time'");
-- goto err;
-+ goto err_mutex;
- }
-
- int dump_cb_block_size = PROXMOX_BACKUP_DEFAULT_CHUNK_SIZE; // Hardcoded (4M)
-@@ -733,12 +748,12 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
- "proxmox_backup_new failed: %s", pbs_err);
- proxmox_backup_free_error(pbs_err);
-- goto err;
-+ goto err_mutex;
- }
-
- int connect_result = proxmox_backup_co_connect(pbs, task->errp);
- if (connect_result < 0)
-- goto err;
-+ goto err_mutex;
-
- /* register all devices */
- l = di_list;
-@@ -749,6 +764,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- di->block_size = dump_cb_block_size;
-
- const char *devname = bdrv_get_device_name(di->bs);
-+ PBSBitmapAction action = PBS_BITMAP_ACTION_NOT_USED;
-+ size_t dirty = di->size;
-
- BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(di->bs, PBS_BITMAP_NAME);
- bool expect_only_dirty = false;
-@@ -757,49 +774,59 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- if (bitmap == NULL) {
- bitmap = bdrv_create_dirty_bitmap(di->bs, dump_cb_block_size, PBS_BITMAP_NAME, task->errp);
- if (!bitmap) {
-- goto err;
-+ goto err_mutex;
- }
-+ action = PBS_BITMAP_ACTION_NEW;
- } else {
- expect_only_dirty = proxmox_backup_check_incremental(pbs, devname, di->size) != 0;
- }
-
- if (expect_only_dirty) {
-- dirty += bdrv_get_dirty_count(bitmap);
-+ /* track clean chunks as reused */
-+ dirty = MIN(bdrv_get_dirty_count(bitmap), di->size);
-+ backup_state.stat.reused += di->size - dirty;
-+ action = PBS_BITMAP_ACTION_USED;
- } else {
- /* mark entire bitmap as dirty to make full backup */
- bdrv_set_dirty_bitmap(bitmap, 0, di->size);
-- dirty += di->size;
-+ if (action != PBS_BITMAP_ACTION_NEW) {
-+ action = PBS_BITMAP_ACTION_INVALID;
-+ }
- }
- di->bitmap = bitmap;
- } else {
-- dirty += di->size;
--
- /* after a full backup the old dirty bitmap is invalid anyway */
- if (bitmap != NULL) {
- bdrv_release_dirty_bitmap(bitmap);
-+ action = PBS_BITMAP_ACTION_NOT_USED_REMOVED;
- }
- }
-
- int dev_id = proxmox_backup_co_register_image(pbs, devname, di->size, expect_only_dirty, task->errp);
- if (dev_id < 0) {
-- goto err;
-+ goto err_mutex;
- }
-
- if (!(di->target = bdrv_backup_dump_create(dump_cb_block_size, di->size, pvebackup_co_dump_pbs_cb, di, task->errp))) {
-- goto err;
-+ goto err_mutex;
- }
-
- di->dev_id = dev_id;
-+
-+ PBSBitmapInfo *info = g_malloc(sizeof(*info));
-+ info->drive = g_strdup(devname);
-+ info->action = action;
-+ info->size = di->size;
-+ info->dirty = dirty;
-+ backup_state.stat.bitmap_list = g_list_append(backup_state.stat.bitmap_list, info);
- }
- } else if (format == BACKUP_FORMAT_VMA) {
-- dirty = total;
--
- vmaw = vma_writer_create(task->backup_file, uuid, &local_err);
- if (!vmaw) {
- if (local_err) {
- error_propagate(task->errp, local_err);
- }
-- goto err;
-+ goto err_mutex;
- }
-
- /* register all devices for vma writer */
-@@ -809,7 +836,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- l = g_list_next(l);
-
- if (!(di->target = bdrv_backup_dump_create(VMA_CLUSTER_SIZE, di->size, pvebackup_co_dump_vma_cb, di, task->errp))) {
-- goto err;
-+ goto err_mutex;
- }
-
- const char *devname = bdrv_get_device_name(di->bs);
-@@ -817,16 +844,14 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- if (di->dev_id <= 0) {
- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR,
- "register_stream failed");
-- goto err;
-+ goto err_mutex;
- }
- }
- } else if (format == BACKUP_FORMAT_DIR) {
-- dirty = total;
--
- if (mkdir(task->backup_file, 0640) != 0) {
- error_setg_errno(task->errp, errno, "can't create directory '%s'\n",
- task->backup_file);
-- goto err;
-+ goto err_mutex;
- }
- backup_dir = task->backup_file;
-
-@@ -843,18 +868,18 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- di->size, flags, false, &local_err);
- if (local_err) {
- error_propagate(task->errp, local_err);
-- goto err;
-+ goto err_mutex;
- }
-
- di->target = bdrv_open(di->targetfile, NULL, NULL, flags, &local_err);
- if (!di->target) {
- error_propagate(task->errp, local_err);
-- goto err;
-+ goto err_mutex;
- }
- }
- } else {
- error_set(task->errp, ERROR_CLASS_GENERIC_ERROR, "unknown backup format");
-- goto err;
-+ goto err_mutex;
- }
-
-
-@@ -862,7 +887,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- if (task->has_config_file) {
- if (pvebackup_co_add_config(task->config_file, config_name, format, backup_dir,
- vmaw, pbs, task->errp) != 0) {
-- goto err;
-+ goto err_mutex;
- }
- }
-
-@@ -870,12 +895,11 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- if (task->has_firewall_file) {
- if (pvebackup_co_add_config(task->firewall_file, firewall_name, format, backup_dir,
- vmaw, pbs, task->errp) != 0) {
-- goto err;
-+ goto err_mutex;
- }
- }
- /* initialize global backup_state now */
--
-- qemu_mutex_lock(&backup_state.stat.lock);
-+ /* note: 'reused' and 'bitmap_list' are initialized earlier */
-
- if (backup_state.stat.error) {
- error_free(backup_state.stat.error);
-@@ -895,10 +919,9 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- char *uuid_str = g_strdup(backup_state.stat.uuid_str);
-
- backup_state.stat.total = total;
-- backup_state.stat.dirty = dirty;
-+ backup_state.stat.dirty = total - backup_state.stat.reused;
- backup_state.stat.transferred = 0;
- backup_state.stat.zero_bytes = 0;
-- backup_state.stat.reused = format == BACKUP_FORMAT_PBS && dirty >= total ? 0 : total - dirty;
-
- qemu_mutex_unlock(&backup_state.stat.lock);
-
-@@ -915,6 +938,9 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
- task->result = uuid_info;
- return;
-
-+err_mutex:
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-+
- err:
-
- l = di_list;
-@@ -1078,9 +1104,40 @@ BackupStatus *qmp_query_backup(Error **errp)
- return info;
- }
-
-+PBSBitmapInfoList *qmp_query_pbs_bitmap_info(Error **errp)
-+{
-+ PBSBitmapInfoList *head = NULL, **p_next = &head;
-+
-+ qemu_mutex_lock(&backup_state.stat.lock);
-+
-+ GList *l = backup_state.stat.bitmap_list;
-+ while (l) {
-+ PBSBitmapInfo *info = (PBSBitmapInfo *)l->data;
-+ l = g_list_next(l);
-+
-+ /* clone bitmap info to avoid auto free after QMP marshalling */
-+ PBSBitmapInfo *info_ret = g_malloc0(sizeof(*info_ret));
-+ info_ret->drive = g_strdup(info->drive);
-+ info_ret->action = info->action;
-+ info_ret->size = info->size;
-+ info_ret->dirty = info->dirty;
-+
-+ PBSBitmapInfoList *info_list = g_malloc0(sizeof(*info_list));
-+ info_list->value = info_ret;
-+
-+ *p_next = info_list;
-+ p_next = &info_list->next;
-+ }
-+
-+ qemu_mutex_unlock(&backup_state.stat.lock);
-+
-+ return head;
-+}
-+
- ProxmoxSupportStatus *qmp_query_proxmox_support(Error **errp)
- {
- ProxmoxSupportStatus *ret = g_malloc0(sizeof(*ret));
- ret->pbs_dirty_bitmap = true;
-+ ret->query_bitmap_info = true;
- return ret;
- }
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index 6dd5e35473..5fc42e87f3 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -885,9 +885,11 @@
- # @pbs-dirty-bitmap: True if dirty-bitmap-incremental backups to PBS are
- # supported.
- #
-+# @query-bitmap-info: True if the 'query-pbs-bitmap-info' QMP call is supported.
-+#
- ##
- { 'struct': 'ProxmoxSupportStatus',
-- 'data': { 'pbs-dirty-bitmap': 'bool' } }
-+ 'data': { 'pbs-dirty-bitmap': 'bool', 'query-bitmap-info': 'bool' } }
-
- ##
- # @query-proxmox-support:
-@@ -899,6 +901,59 @@
- ##
- { 'command': 'query-proxmox-support', 'returns': 'ProxmoxSupportStatus' }
-
-+##
-+# @PBSBitmapAction:
-+#
-+# An action taken on a dirty-bitmap when a backup job was started.
-+#
-+# @not-used: Bitmap mode was not enabled.
-+#
-+# @not-used-removed: Bitmap mode was not enabled, but a bitmap from a
-+# previous backup still existed and was removed.
-+#
-+# @new: A new bitmap was attached to the drive for this backup.
-+#
-+# @used: An existing bitmap will be used to only backup changed data.
-+#
-+# @invalid: A bitmap existed, but had to be cleared since it's associated
-+# base snapshot did not match the base given for the current job or
-+# the crypt mode has changed.
-+#
-+##
-+{ 'enum': 'PBSBitmapAction',
-+ 'data': ['not-used', 'not-used-removed', 'new', 'used', 'invalid'] }
-+
-+##
-+# @PBSBitmapInfo:
-+#
-+# Contains information about dirty bitmaps used for each drive in a PBS backup.
-+#
-+# @drive: The underlying drive.
-+#
-+# @action: The action that was taken when the backup started.
-+#
-+# @size: The total size of the drive.
-+#
-+# @dirty: How much of the drive is considered dirty and will be backed up,
-+# or 'size' if everything will be.
-+#
-+##
-+{ 'struct': 'PBSBitmapInfo',
-+ 'data': { 'drive': 'str', 'action': 'PBSBitmapAction', 'size': 'int',
-+ 'dirty': 'int' } }
-+
-+##
-+# @query-pbs-bitmap-info:
-+#
-+# Returns information about dirty bitmaps used on the most recently started
-+# backup. Returns nothing when the last backup was not using PBS or if no
-+# backup occured in this session.
-+#
-+# Returns: @PBSBitmapInfo
-+#
-+##
-+{ 'command': 'query-pbs-bitmap-info', 'returns': ['PBSBitmapInfo'] }
-+
- ##
- # @BlockDeviceTimedStats:
- #
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Tue, 30 Jun 2020 13:10:10 +0200
+Subject: [PATCH] PVE: redirect stderr to journal when daemonized
+
+QEMU uses the logging for error messages usually, so LOG_ERR is most
+fitting.
+---
+ Makefile.objs | 1 +
+ os-posix.c | 7 +++++--
+ 2 files changed, 6 insertions(+), 2 deletions(-)
+
+diff --git a/Makefile.objs b/Makefile.objs
+index 240eb503f2..c7ba4e11e7 100644
+--- a/Makefile.objs
++++ b/Makefile.objs
+@@ -54,6 +54,7 @@ common-obj-y += net/
+ common-obj-y += qdev-monitor.o
+ common-obj-$(CONFIG_WIN32) += os-win32.o
+ common-obj-$(CONFIG_POSIX) += os-posix.o
++os-posix.o-libs := -lsystemd
+
+ common-obj-$(CONFIG_LINUX) += fsdev/
+
+diff --git a/os-posix.c b/os-posix.c
+index 3572db3f44..b45dde63ac 100644
+--- a/os-posix.c
++++ b/os-posix.c
+@@ -28,6 +28,8 @@
+ #include <pwd.h>
+ #include <grp.h>
+ #include <libgen.h>
++#include <systemd/sd-journal.h>
++#include <syslog.h>
+
+ #include "qemu-common.h"
+ /* Needed early for CONFIG_BSD etc. */
+@@ -312,9 +314,10 @@ void os_setup_post(void)
+
+ dup2(fd, 0);
+ dup2(fd, 1);
+- /* In case -D is given do not redirect stderr to /dev/null */
++ /* In case -D is given do not redirect stderr to journal */
+ if (!qemu_logfile) {
+- dup2(fd, 2);
++ int journal_fd = sd_journal_stream_fd("QEMU", LOG_ERR, 0);
++ dup2(journal_fd, 2);
+ }
+
+ close(fd);
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Thu, 20 Aug 2020 14:31:59 +0200
+Subject: [PATCH] PVE: Add sequential job transaction support
+
+---
+ include/qemu/job.h | 12 ++++++++++++
+ job.c | 24 ++++++++++++++++++++++++
+ 2 files changed, 36 insertions(+)
+
+diff --git a/include/qemu/job.h b/include/qemu/job.h
+index 32aabb1c60..f7a6a0926a 100644
+--- a/include/qemu/job.h
++++ b/include/qemu/job.h
+@@ -280,6 +280,18 @@ typedef enum JobCreateFlags {
+ */
+ JobTxn *job_txn_new(void);
+
++/**
++ * Create a new transaction and set it to sequential mode, i.e. run all jobs
++ * one after the other instead of at the same time.
++ */
++JobTxn *job_txn_new_seq(void);
++
++/**
++ * Helper method to start the first job in a sequential transaction to kick it
++ * off. Other jobs will be run after this one completes.
++ */
++void job_txn_start_seq(JobTxn *txn);
++
+ /**
+ * Release a reference that was previously acquired with job_txn_add_job or
+ * job_txn_new. If it's the last reference to the object, it will be freed.
+diff --git a/job.c b/job.c
+index b8139c80a4..97ee97a192 100644
+--- a/job.c
++++ b/job.c
+@@ -72,6 +72,8 @@ struct JobTxn {
+
+ /* Reference count */
+ int refcnt;
++
++ bool sequential;
+ };
+
+ /* Right now, this mutex is only needed to synchronize accesses to job->busy
+@@ -102,6 +104,25 @@ JobTxn *job_txn_new(void)
+ return txn;
+ }
+
++JobTxn *job_txn_new_seq(void)
++{
++ JobTxn *txn = job_txn_new();
++ txn->sequential = true;
++ return txn;
++}
++
++void job_txn_start_seq(JobTxn *txn)
++{
++ assert(txn->sequential);
++ assert(!txn->aborting);
++
++ Job *first = QLIST_FIRST(&txn->jobs);
++ assert(first);
++ assert(first->status == JOB_STATUS_CREATED);
++
++ job_start(first);
++}
++
+ static void job_txn_ref(JobTxn *txn)
+ {
+ txn->refcnt++;
+@@ -841,6 +862,9 @@ static void job_completed_txn_success(Job *job)
+ */
+ QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
+ if (!job_is_completed(other_job)) {
++ if (txn->sequential) {
++ job_start(other_job);
++ }
+ return;
+ }
+ assert(other_job->ret == 0);
+++ /dev/null
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Stefan Reiter <s.reiter@proxmox.com>
-Date: Tue, 30 Jun 2020 13:10:10 +0200
-Subject: [PATCH] PVE: redirect stderr to journal when daemonized
-
-QEMU uses the logging for error messages usually, so LOG_ERR is most
-fitting.
----
- Makefile.objs | 1 +
- os-posix.c | 7 +++++--
- 2 files changed, 6 insertions(+), 2 deletions(-)
-
-diff --git a/Makefile.objs b/Makefile.objs
-index b7d58e592e..105f23bff7 100644
---- a/Makefile.objs
-+++ b/Makefile.objs
-@@ -55,6 +55,7 @@ common-obj-y += net/
- common-obj-y += qdev-monitor.o
- common-obj-$(CONFIG_WIN32) += os-win32.o
- common-obj-$(CONFIG_POSIX) += os-posix.o
-+os-posix.o-libs := -lsystemd
-
- common-obj-$(CONFIG_LINUX) += fsdev/
-
-diff --git a/os-posix.c b/os-posix.c
-index 3cd52e1e70..ab4d052c62 100644
---- a/os-posix.c
-+++ b/os-posix.c
-@@ -28,6 +28,8 @@
- #include <pwd.h>
- #include <grp.h>
- #include <libgen.h>
-+#include <systemd/sd-journal.h>
-+#include <syslog.h>
-
- #include "qemu-common.h"
- /* Needed early for CONFIG_BSD etc. */
-@@ -309,9 +311,10 @@ void os_setup_post(void)
-
- dup2(fd, 0);
- dup2(fd, 1);
-- /* In case -D is given do not redirect stderr to /dev/null */
-+ /* In case -D is given do not redirect stderr to journal */
- if (!qemu_logfile) {
-- dup2(fd, 2);
-+ int journal_fd = sd_journal_stream_fd("QEMU", LOG_ERR, 0);
-+ dup2(journal_fd, 2);
- }
-
- close(fd);
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Thu, 20 Aug 2020 14:25:00 +0200
+Subject: [PATCH] PVE-Backup: Use a transaction to synchronize job states
+
+By using a JobTxn, we can sync dirty bitmaps only when *all* jobs were
+successful - meaning we don't need to remove them when the backup fails,
+since QEMU's BITMAP_SYNC_MODE_ON_SUCCESS will now handle that for us.
+
+To keep the rate-limiting and IO impact from before, we use a sequential
+transaction, so drives will still be backed up one after the other.
+---
+ pve-backup.c | 167 +++++++++++++++------------------------------------
+ 1 file changed, 49 insertions(+), 118 deletions(-)
+
+diff --git a/pve-backup.c b/pve-backup.c
+index 04c21c80aa..9562e9c98d 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -52,6 +52,7 @@ static struct PVEBackupState {
+ VmaWriter *vmaw;
+ ProxmoxBackupHandle *pbs;
+ GList *di_list;
++ JobTxn *txn;
+ QemuMutex backup_mutex;
+ CoMutex dump_callback_mutex;
+ } backup_state;
+@@ -71,32 +72,12 @@ typedef struct PVEBackupDevInfo {
+ size_t size;
+ uint64_t block_size;
+ uint8_t dev_id;
+- bool completed;
+ char targetfile[PATH_MAX];
+ BdrvDirtyBitmap *bitmap;
+ BlockDriverState *target;
++ BlockJob *job;
+ } PVEBackupDevInfo;
+
+-static void pvebackup_run_next_job(void);
+-
+-static BlockJob *
+-lookup_active_block_job(PVEBackupDevInfo *di)
+-{
+- if (!di->completed && di->bs) {
+- for (BlockJob *job = block_job_next(NULL); job; job = block_job_next(job)) {
+- if (job->job.driver->job_type != JOB_TYPE_BACKUP) {
+- continue;
+- }
+-
+- BackupBlockJob *bjob = container_of(job, BackupBlockJob, common);
+- if (bjob && bjob->source_bs == di->bs) {
+- return job;
+- }
+- }
+- }
+- return NULL;
+-}
+-
+ static void pvebackup_propagate_error(Error *err)
+ {
+ qemu_mutex_lock(&backup_state.stat.lock);
+@@ -272,18 +253,6 @@ static void coroutine_fn pvebackup_co_cleanup(void *unused)
+ if (local_err != NULL) {
+ pvebackup_propagate_error(local_err);
+ }
+- } else {
+- // on error or cancel we cannot ensure synchronization of dirty
+- // bitmaps with backup server, so remove all and do full backup next
+- GList *l = backup_state.di_list;
+- while (l) {
+- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+- l = g_list_next(l);
+-
+- if (di->bitmap) {
+- bdrv_release_dirty_bitmap(di->bitmap);
+- }
+- }
+ }
+
+ proxmox_backup_disconnect(backup_state.pbs);
+@@ -322,8 +291,6 @@ static void pvebackup_complete_cb(void *opaque, int ret)
+
+ qemu_mutex_lock(&backup_state.backup_mutex);
+
+- di->completed = true;
+-
+ if (ret < 0) {
+ Error *local_err = NULL;
+ error_setg(&local_err, "job failed with err %d - %s", ret, strerror(-ret));
+@@ -336,20 +303,17 @@ static void pvebackup_complete_cb(void *opaque, int ret)
+
+ block_on_coroutine_fn(pvebackup_complete_stream, di);
+
+- // remove self from job queue
++ // remove self from job list
+ backup_state.di_list = g_list_remove(backup_state.di_list, di);
+
+- if (di->bitmap && ret < 0) {
+- // on error or cancel we cannot ensure synchronization of dirty
+- // bitmaps with backup server, so remove all and do full backup next
+- bdrv_release_dirty_bitmap(di->bitmap);
+- }
+-
+ g_free(di);
+
+- qemu_mutex_unlock(&backup_state.backup_mutex);
++ /* call cleanup if we're the last job */
++ if (!g_list_first(backup_state.di_list)) {
++ block_on_coroutine_fn(pvebackup_co_cleanup, NULL);
++ }
+
+- pvebackup_run_next_job();
++ qemu_mutex_unlock(&backup_state.backup_mutex);
+ }
+
+ static void pvebackup_cancel(void)
+@@ -371,36 +335,28 @@ static void pvebackup_cancel(void)
+ proxmox_backup_abort(backup_state.pbs, "backup canceled");
+ }
+
+- qemu_mutex_unlock(&backup_state.backup_mutex);
+-
+- for(;;) {
+-
+- BlockJob *next_job = NULL;
+-
+- qemu_mutex_lock(&backup_state.backup_mutex);
+-
+- GList *l = backup_state.di_list;
+- while (l) {
+- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+- l = g_list_next(l);
++ /* it's enough to cancel one job in the transaction, the rest will follow
++ * automatically */
++ GList *bdi = g_list_first(backup_state.di_list);
++ BlockJob *cancel_job = bdi && bdi->data ?
++ ((PVEBackupDevInfo *)bdi->data)->job :
++ NULL;
+
+- BlockJob *job = lookup_active_block_job(di);
+- if (job != NULL) {
+- next_job = job;
+- break;
+- }
+- }
++ /* ref the job before releasing the mutex, just to be safe */
++ if (cancel_job) {
++ job_ref(&cancel_job->job);
++ }
+
+- qemu_mutex_unlock(&backup_state.backup_mutex);
++ /* job_cancel_sync may enter the job, so we need to release the
++ * backup_mutex to avoid deadlock */
++ qemu_mutex_unlock(&backup_state.backup_mutex);
+
+- if (next_job) {
+- AioContext *aio_context = next_job->job.aio_context;
+- aio_context_acquire(aio_context);
+- job_cancel_sync(&next_job->job);
+- aio_context_release(aio_context);
+- } else {
+- break;
+- }
++ if (cancel_job) {
++ AioContext *aio_context = cancel_job->job.aio_context;
++ aio_context_acquire(aio_context);
++ job_cancel_sync(&cancel_job->job);
++ job_unref(&cancel_job->job);
++ aio_context_release(aio_context);
+ }
+ }
+
+@@ -459,51 +415,19 @@ static int coroutine_fn pvebackup_co_add_config(
+ goto out;
+ }
+
+-bool job_should_pause(Job *job);
+-
+-static void pvebackup_run_next_job(void)
+-{
+- assert(!qemu_in_coroutine());
+-
+- qemu_mutex_lock(&backup_state.backup_mutex);
+-
+- GList *l = backup_state.di_list;
+- while (l) {
+- PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+- l = g_list_next(l);
+-
+- BlockJob *job = lookup_active_block_job(di);
+-
+- if (job) {
+- qemu_mutex_unlock(&backup_state.backup_mutex);
+-
+- AioContext *aio_context = job->job.aio_context;
+- aio_context_acquire(aio_context);
+-
+- if (job_should_pause(&job->job)) {
+- bool error_or_canceled = pvebackup_error_or_canceled();
+- if (error_or_canceled) {
+- job_cancel_sync(&job->job);
+- } else {
+- job_resume(&job->job);
+- }
+- }
+- aio_context_release(aio_context);
+- return;
+- }
+- }
+-
+- block_on_coroutine_fn(pvebackup_co_cleanup, NULL); // no more jobs, run cleanup
+-
+- qemu_mutex_unlock(&backup_state.backup_mutex);
+-}
+-
+ static bool create_backup_jobs(void) {
+
+ assert(!qemu_in_coroutine());
+
+ Error *local_err = NULL;
+
++ /* create job transaction to synchronize bitmap commit and cancel all
++ * jobs in case one errors */
++ if (backup_state.txn) {
++ job_txn_unref(backup_state.txn);
++ }
++ backup_state.txn = job_txn_new_seq();
++
+ /* create and start all jobs (paused state) */
+ GList *l = backup_state.di_list;
+ while (l) {
+@@ -524,7 +448,7 @@ static bool create_backup_jobs(void) {
+ BlockJob *job = backup_job_create(
+ NULL, di->bs, di->target, backup_state.speed, sync_mode, di->bitmap,
+ bitmap_mode, false, NULL, BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
+- JOB_DEFAULT, pvebackup_complete_cb, di, 1, NULL, &local_err);
++ JOB_DEFAULT, pvebackup_complete_cb, di, backup_state.txn, &local_err);
+
+ aio_context_release(aio_context);
+
+@@ -536,7 +460,8 @@ static bool create_backup_jobs(void) {
+ pvebackup_propagate_error(create_job_err);
+ break;
+ }
+- job_start(&job->job);
++
++ di->job = job;
+
+ bdrv_unref(di->target);
+ di->target = NULL;
+@@ -554,6 +479,10 @@ static bool create_backup_jobs(void) {
+ bdrv_unref(di->target);
+ di->target = NULL;
+ }
++
++ if (di->job) {
++ job_unref(&di->job->job);
++ }
+ }
+ }
+
+@@ -944,10 +873,6 @@ err:
+ PVEBackupDevInfo *di = (PVEBackupDevInfo *)l->data;
+ l = g_list_next(l);
+
+- if (di->bitmap) {
+- bdrv_release_dirty_bitmap(di->bitmap);
+- }
+-
+ if (di->target) {
+ bdrv_unref(di->target);
+ }
+@@ -1036,9 +961,15 @@ UuidInfo *qmp_backup(
+ block_on_coroutine_fn(pvebackup_co_prepare, &task);
+
+ if (*errp == NULL) {
+- create_backup_jobs();
++ bool errors = create_backup_jobs();
+ qemu_mutex_unlock(&backup_state.backup_mutex);
+- pvebackup_run_next_job();
++
++ if (!errors) {
++ /* start the first job in the transaction
++ * note: this might directly enter the job, so we need to do this
++ * after unlocking the backup_mutex */
++ job_txn_start_seq(backup_state.txn);
++ }
+ } else {
+ qemu_mutex_unlock(&backup_state.backup_mutex);
+ }
--- /dev/null
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Stefan Reiter <s.reiter@proxmox.com>
+Date: Mon, 28 Sep 2020 13:40:51 +0200
+Subject: [PATCH] PVE-Backup: Use more coroutines and don't block on finishing
+
+proxmox_backup_co_finish is already async, but previously we would wait
+for the coroutine using block_on_coroutine_fn(). Avoid this by
+scheduling pvebackup_co_complete_stream (and thus pvebackup_co_cleanup)
+as a real coroutine when calling from pvebackup_complete_cb. This is ok,
+since complete_stream uses the backup_mutex internally to synchronize,
+and other streams can happily continue writing in the meantime anyway.
+
+To accomodate, backup_mutex is converted to a CoMutex. This means
+converting every user to a coroutine. This is not just useful here, but
+will come in handy once this series[0] is merged, and QMP calls can be
+yield-able coroutines too. Then we can also finally get rid of
+block_on_coroutine_fn.
+
+Cases of aio_context_acquire/release from within what is now a coroutine
+are changed to aio_co_reschedule_self, which works since a running
+coroutine always holds the aio lock for the context it is running in.
+
+job_cancel_sync is changed to regular job_cancel, since job_cancel_sync
+uses AIO_WAIT_WHILE internally, which is forbidden from Coroutines.
+
+create_backup_jobs cannot be run from a coroutine, so it is run
+directly. This does however mean that it runs unlocked, as it cannot
+acquire a CoMutex (see it's comment for rational on why that's ok).
+
+To communicate the finishing state, a new property is introduced to
+query-backup: 'finishing'. A new state is explicitly not used, since
+that would break compatibility with older qemu-server versions.
+
+[0] https://lists.gnu.org/archive/html/qemu-devel/2020-09/msg03515.html
+---
+ proxmox-backup-client.h | 1 +
+ pve-backup.c | 124 ++++++++++++++++++++++------------------
+ qapi/block-core.json | 5 +-
+ 3 files changed, 74 insertions(+), 56 deletions(-)
+
+diff --git a/proxmox-backup-client.h b/proxmox-backup-client.h
+index 20fd6b1719..a4781c5851 100644
+--- a/proxmox-backup-client.h
++++ b/proxmox-backup-client.h
+@@ -5,6 +5,7 @@
+ #include "qemu/coroutine.h"
+ #include "proxmox-backup-qemu.h"
+
++// FIXME: Remove once coroutines are supported for QMP
+ void block_on_coroutine_fn(CoroutineEntry *entry, void *entry_arg);
+
+ int coroutine_fn
+diff --git a/pve-backup.c b/pve-backup.c
+index 9562e9c98d..53cf23ed5a 100644
+--- a/pve-backup.c
++++ b/pve-backup.c
+@@ -33,7 +33,9 @@ const char *PBS_BITMAP_NAME = "pbs-incremental-dirty-bitmap";
+
+ static struct PVEBackupState {
+ struct {
+- // Everithing accessed from qmp_backup_query command is protected using lock
++ // Everything accessed from qmp_backup_query command is protected using
++ // this lock. Do NOT hold this lock for long times, as it is sometimes
++ // acquired from coroutines, and thus any wait time may block the guest.
+ QemuMutex lock;
+ Error *error;
+ time_t start_time;
+@@ -47,20 +49,21 @@ static struct PVEBackupState {
+ size_t reused;
+ size_t zero_bytes;
+ GList *bitmap_list;
++ bool finishing;
+ } stat;
+ int64_t speed;
+ VmaWriter *vmaw;
+ ProxmoxBackupHandle *pbs;
+ GList *di_list;
+ JobTxn *txn;
+- QemuMutex backup_mutex;
++ CoMutex backup_mutex;
+ CoMutex dump_callback_mutex;
+ } backup_state;
+
+ static void pvebackup_init(void)
+ {
+ qemu_mutex_init(&backup_state.stat.lock);
+- qemu_mutex_init(&backup_state.backup_mutex);
++ qemu_co_mutex_init(&backup_state.backup_mutex);
+ qemu_co_mutex_init(&backup_state.dump_callback_mutex);
+ }
+
+@@ -72,6 +75,7 @@ typedef struct PVEBackupDevInfo {
+ size_t size;
+ uint64_t block_size;
+ uint8_t dev_id;
++ int completed_ret; // INT_MAX if not completed
+ char targetfile[PATH_MAX];
+ BdrvDirtyBitmap *bitmap;
+ BlockDriverState *target;
+@@ -227,12 +231,12 @@ pvebackup_co_dump_vma_cb(
+ }
+
+ // assumes the caller holds backup_mutex
+-static void coroutine_fn pvebackup_co_cleanup(void *unused)
++static void coroutine_fn pvebackup_co_cleanup(void)
+ {
+ assert(qemu_in_coroutine());
+
+ qemu_mutex_lock(&backup_state.stat.lock);
+- backup_state.stat.end_time = time(NULL);
++ backup_state.stat.finishing = true;
+ qemu_mutex_unlock(&backup_state.stat.lock);
+
+ if (backup_state.vmaw) {
+@@ -261,12 +265,29 @@ static void coroutine_fn pvebackup_co_cleanup(void *unused)
+
+ g_list_free(backup_state.di_list);
+ backup_state.di_list = NULL;
++
++ qemu_mutex_lock(&backup_state.stat.lock);
++ backup_state.stat.end_time = time(NULL);
++ backup_state.stat.finishing = false;
++ qemu_mutex_unlock(&backup_state.stat.lock);
+ }
+
+-// assumes the caller holds backup_mutex
+-static void coroutine_fn pvebackup_complete_stream(void *opaque)
++static void coroutine_fn pvebackup_co_complete_stream(void *opaque)
+ {
+ PVEBackupDevInfo *di = opaque;
++ int ret = di->completed_ret;
++
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
++ if (ret < 0) {
++ Error *local_err = NULL;
++ error_setg(&local_err, "job failed with err %d - %s", ret, strerror(-ret));
++ pvebackup_propagate_error(local_err);
++ }
++
++ di->bs = NULL;
++
++ assert(di->target == NULL);
+
+ bool error_or_canceled = pvebackup_error_or_canceled();
+
+@@ -281,27 +302,6 @@ static void coroutine_fn pvebackup_complete_stream(void *opaque)
+ pvebackup_propagate_error(local_err);
+ }
+ }
+-}
+-
+-static void pvebackup_complete_cb(void *opaque, int ret)
+-{
+- assert(!qemu_in_coroutine());
+-
+- PVEBackupDevInfo *di = opaque;
+-
+- qemu_mutex_lock(&backup_state.backup_mutex);
+-
+- if (ret < 0) {
+- Error *local_err = NULL;
+- error_setg(&local_err, "job failed with err %d - %s", ret, strerror(-ret));
+- pvebackup_propagate_error(local_err);
+- }
+-
+- di->bs = NULL;
+-
+- assert(di->target == NULL);
+-
+- block_on_coroutine_fn(pvebackup_complete_stream, di);
+
+ // remove self from job list
+ backup_state.di_list = g_list_remove(backup_state.di_list, di);
+@@ -310,21 +310,36 @@ static void pvebackup_complete_cb(void *opaque, int ret)
+
+ /* call cleanup if we're the last job */
+ if (!g_list_first(backup_state.di_list)) {
+- block_on_coroutine_fn(pvebackup_co_cleanup, NULL);
++ pvebackup_co_cleanup();
+ }
+
+- qemu_mutex_unlock(&backup_state.backup_mutex);
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
+ }
+
+-static void pvebackup_cancel(void)
++static void pvebackup_complete_cb(void *opaque, int ret)
+ {
+ assert(!qemu_in_coroutine());
+
++ PVEBackupDevInfo *di = opaque;
++ di->completed_ret = ret;
++
++ /*
++ * Schedule stream cleanup in async coroutine. close_image and finish might
++ * take a while, so we can't block on them here.
++ * Note: di is a pointer to an entry in the global backup_state struct, so
++ * it stays valid.
++ */
++ Coroutine *co = qemu_coroutine_create(pvebackup_co_complete_stream, di);
++ aio_co_schedule(qemu_get_aio_context(), co);
++}
++
++static void coroutine_fn pvebackup_co_cancel(void *opaque)
++{
+ Error *cancel_err = NULL;
+ error_setg(&cancel_err, "backup canceled");
+ pvebackup_propagate_error(cancel_err);
+
+- qemu_mutex_lock(&backup_state.backup_mutex);
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
+
+ if (backup_state.vmaw) {
+ /* make sure vma writer does not block anymore */
+@@ -342,27 +357,16 @@ static void pvebackup_cancel(void)
+ ((PVEBackupDevInfo *)bdi->data)->job :
+ NULL;
+
+- /* ref the job before releasing the mutex, just to be safe */
+ if (cancel_job) {
+- job_ref(&cancel_job->job);
++ job_cancel(&cancel_job->job, false);
+ }
+
+- /* job_cancel_sync may enter the job, so we need to release the
+- * backup_mutex to avoid deadlock */
+- qemu_mutex_unlock(&backup_state.backup_mutex);
+-
+- if (cancel_job) {
+- AioContext *aio_context = cancel_job->job.aio_context;
+- aio_context_acquire(aio_context);
+- job_cancel_sync(&cancel_job->job);
+- job_unref(&cancel_job->job);
+- aio_context_release(aio_context);
+- }
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
+ }
+
+ void qmp_backup_cancel(Error **errp)
+ {
+- pvebackup_cancel();
++ block_on_coroutine_fn(pvebackup_co_cancel, NULL);
+ }
+
+ // assumes the caller holds backup_mutex
+@@ -415,6 +419,14 @@ static int coroutine_fn pvebackup_co_add_config(
+ goto out;
+ }
+
++/*
++ * backup_job_create can *not* be run from a coroutine (and requires an
++ * acquired AioContext), so this can't either.
++ * This does imply that this function cannot run with backup_mutex acquired.
++ * That is ok because it is only ever called between setting up the backup_state
++ * struct and starting the jobs, and from within a QMP call. This means that no
++ * other QMP call can interrupt, and no background job is running yet.
++ */
+ static bool create_backup_jobs(void) {
+
+ assert(!qemu_in_coroutine());
+@@ -523,11 +535,12 @@ typedef struct QmpBackupTask {
+ UuidInfo *result;
+ } QmpBackupTask;
+
+-// assumes the caller holds backup_mutex
+ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ {
+ assert(qemu_in_coroutine());
+
++ qemu_co_mutex_lock(&backup_state.backup_mutex);
++
+ QmpBackupTask *task = opaque;
+
+ task->result = NULL; // just to be sure
+@@ -616,6 +629,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ }
+ di->size = size;
+ total += size;
++
++ di->completed_ret = INT_MAX;
+ }
+
+ uuid_generate(uuid);
+@@ -847,6 +862,7 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ backup_state.stat.dirty = total - backup_state.stat.reused;
+ backup_state.stat.transferred = 0;
+ backup_state.stat.zero_bytes = 0;
++ backup_state.stat.finishing = false;
+
+ qemu_mutex_unlock(&backup_state.stat.lock);
+
+@@ -861,6 +877,8 @@ static void coroutine_fn pvebackup_co_prepare(void *opaque)
+ uuid_info->UUID = uuid_str;
+
+ task->result = uuid_info;
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
+ return;
+
+ err_mutex:
+@@ -903,6 +921,8 @@ err:
+ }
+
+ task->result = NULL;
++
++ qemu_co_mutex_unlock(&backup_state.backup_mutex);
+ return;
+ }
+
+@@ -956,22 +976,15 @@ UuidInfo *qmp_backup(
+ .errp = errp,
+ };
+
+- qemu_mutex_lock(&backup_state.backup_mutex);
+-
+ block_on_coroutine_fn(pvebackup_co_prepare, &task);
+
+ if (*errp == NULL) {
+ bool errors = create_backup_jobs();
+- qemu_mutex_unlock(&backup_state.backup_mutex);
+
+ if (!errors) {
+- /* start the first job in the transaction
+- * note: this might directly enter the job, so we need to do this
+- * after unlocking the backup_mutex */
++ // start the first job in the transaction
+ job_txn_start_seq(backup_state.txn);
+ }
+- } else {
+- qemu_mutex_unlock(&backup_state.backup_mutex);
+ }
+
+ return task.result;
+@@ -1025,6 +1038,7 @@ BackupStatus *qmp_query_backup(Error **errp)
+ info->transferred = backup_state.stat.transferred;
+ info->has_reused = true;
+ info->reused = backup_state.stat.reused;
++ info->finishing = backup_state.stat.finishing;
+
+ qemu_mutex_unlock(&backup_state.stat.lock);
+
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index 5fc42e87f3..b31ad8d989 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -784,12 +784,15 @@
+ #
+ # @uuid: uuid for this backup job
+ #
++# @finishing: if status='active' and finishing=true, then the backup process is
++# waiting for the target to finish.
++#
+ ##
+ { 'struct': 'BackupStatus',
+ 'data': {'*status': 'str', '*errmsg': 'str', '*total': 'int', '*dirty': 'int',
+ '*transferred': 'int', '*zero-bytes': 'int', '*reused': 'int',
+ '*start-time': 'int', '*end-time': 'int',
+- '*backup-file': 'str', '*uuid': 'str' } }
++ '*backup-file': 'str', '*uuid': 'str', 'finishing': 'bool' } }
+
+ ##
+ # @BackupFormat:
pve/0023-PVE-monitor-disable-oob-capability.patch
pve/0024-PVE-Compat-4.0-used-balloon-qemu-4-0-config-size-fal.patch
pve/0025-PVE-Allow-version-code-in-machine-type.patch
-pve/0026-PVE-Backup-modify-job-api.patch
-pve/0027-PVE-Backup-add-vma-backup-format-code.patch
-pve/0028-PVE-Backup-add-backup-dump-block-driver.patch
-pve/0029-PVE-Backup-proxmox-backup-patches-for-qemu.patch
-pve/0030-PVE-Backup-pbs-restore-new-command-to-restore-from-p.patch
-pve/0031-PVE-Backup-avoid-coroutines-to-fix-AIO-freeze-cleanu.patch
-pve/0032-drive-mirror-add-support-for-sync-bitmap-mode-never.patch
-pve/0033-drive-mirror-add-support-for-conditional-and-always-.patch
-pve/0034-mirror-add-check-for-bitmap-mode-without-bitmap.patch
-pve/0035-mirror-switch-to-bdrv_dirty_bitmap_merge_internal.patch
-pve/0036-iotests-add-test-for-bitmap-mirror.patch
-pve/0037-mirror-move-some-checks-to-qmp.patch
-pve/0038-PVE-Backup-Add-dirty-bitmap-tracking-for-incremental.patch
-pve/0039-PVE-backup-rename-incremental-to-use-dirty-bitmap.patch
-pve/0040-PVE-fixup-pbs-restore-API.patch
-pve/0041-PVE-always-set-dirty-counter-for-non-incremental-bac.patch
-pve/0042-PVE-use-proxmox_backup_check_incremental.patch
-pve/0043-PVE-fixup-pbs-backup-add-compress-and-encrypt-option.patch
-pve/0044-PVE-Add-PBS-block-driver-to-map-backup-archives-into.patch
-pve/0045-PVE-add-query_proxmox_support-QMP-command.patch
-pve/0046-pbs-fix-missing-crypt-and-compress-parameters.patch
-pve/0047-PVE-handle-PBS-write-callback-with-big-blocks-correc.patch
-pve/0048-PVE-add-zero-block-handling-to-PBS-dump-callback.patch
-pve/0049-PVE-add-query-pbs-bitmap-info-QMP-call.patch
-pve/0050-PVE-redirect-stderr-to-journal-when-daemonized.patch
+pve/0026-PVE-Backup-add-vma-backup-format-code.patch
+pve/0027-PVE-Backup-add-backup-dump-block-driver.patch
+pve/0028-PVE-Backup-proxmox-backup-patches-for-qemu.patch
+pve/0029-PVE-Backup-pbs-restore-new-command-to-restore-from-p.patch
+pve/0030-PVE-Backup-avoid-coroutines-to-fix-AIO-freeze-cleanu.patch
+pve/0031-drive-mirror-add-support-for-sync-bitmap-mode-never.patch
+pve/0032-drive-mirror-add-support-for-conditional-and-always-.patch
+pve/0033-mirror-add-check-for-bitmap-mode-without-bitmap.patch
+pve/0034-mirror-switch-to-bdrv_dirty_bitmap_merge_internal.patch
+pve/0035-iotests-add-test-for-bitmap-mirror.patch
+pve/0036-mirror-move-some-checks-to-qmp.patch
+pve/0037-PVE-Backup-Add-dirty-bitmap-tracking-for-incremental.patch
+pve/0038-PVE-backup-rename-incremental-to-use-dirty-bitmap.patch
+pve/0039-PVE-fixup-pbs-restore-API.patch
+pve/0040-PVE-always-set-dirty-counter-for-non-incremental-bac.patch
+pve/0041-PVE-use-proxmox_backup_check_incremental.patch
+pve/0042-PVE-fixup-pbs-backup-add-compress-and-encrypt-option.patch
+pve/0043-PVE-Add-PBS-block-driver-to-map-backup-archives-into.patch
+pve/0044-PVE-add-query_proxmox_support-QMP-command.patch
+pve/0045-pbs-fix-missing-crypt-and-compress-parameters.patch
+pve/0046-PVE-handle-PBS-write-callback-with-big-blocks-correc.patch
+pve/0047-PVE-add-zero-block-handling-to-PBS-dump-callback.patch
+pve/0048-PVE-add-query-pbs-bitmap-info-QMP-call.patch
+pve/0049-PVE-redirect-stderr-to-journal-when-daemonized.patch
+pve/0050-PVE-Add-sequential-job-transaction-support.patch
+pve/0051-PVE-Backup-Use-a-transaction-to-synchronize-job-stat.patch
+pve/0052-PVE-Backup-Use-more-coroutines-and-don-t-block-on-fi.patch
projects / pve-qemu.git / commitdiff