1 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
2 From: Dietmar Maurer <dietmar@proxmox.com>
3 Date: Mon, 6 Apr 2020 12:16:57 +0200
4 Subject: [PATCH] PVE-Backup: add vma backup format code
9 vma-reader.c | 857 ++++++++++++++++++++++++++++++++++++++++++++++++++
10 vma-writer.c | 790 ++++++++++++++++++++++++++++++++++++++++++++++
11 vma.c | 839 ++++++++++++++++++++++++++++++++++++++++++++++++
13 6 files changed, 2639 insertions(+), 1 deletion(-)
14 create mode 100644 vma-reader.c
15 create mode 100644 vma-writer.c
16 create mode 100644 vma.c
17 create mode 100644 vma.h
19 diff --git a/Makefile b/Makefile
20 index 8a9113e666..74c2039005 100644
23 @@ -479,7 +479,7 @@ dummy := $(call unnest-vars,, \
25 include $(SRC_PATH)/tests/Makefile.include
27 -all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
28 +all: $(DOCS) $(if $(BUILD_DOCS),sphinxdocs) $(TOOLS) vma$(EXESUF) $(HELPERS-y) recurse-all modules $(vhost-user-json-y)
31 $(call quiet-command, \
32 @@ -608,6 +608,7 @@ qemu-img$(EXESUF): qemu-img.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io
33 qemu-nbd$(EXESUF): qemu-nbd.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
34 qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
35 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)
36 +vma$(EXESUF): vma.o vma-reader.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS)
38 qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS)
40 diff --git a/Makefile.objs b/Makefile.objs
41 index d0b4dde836..05031a3da7 100644
44 @@ -18,6 +18,7 @@ block-obj-y += block.o blockjob.o job.o
45 block-obj-y += block/ scsi/
46 block-obj-y += qemu-io-cmds.o
47 block-obj-$(CONFIG_REPLICATION) += replication.o
48 +block-obj-y += vma-writer.o
52 diff --git a/vma-reader.c b/vma-reader.c
54 index 0000000000..2b1d1cdab3
59 + * VMA: Virtual Machine Archive
61 + * Copyright (C) 2012 Proxmox Server Solutions
64 + * Dietmar Maurer (dietmar@proxmox.com)
66 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
67 + * See the COPYING file in the top-level directory.
71 +#include "qemu/osdep.h"
73 +#include <uuid/uuid.h>
75 +#include "qemu-common.h"
76 +#include "qemu/timer.h"
77 +#include "qemu/ratelimit.h"
79 +#include "block/block.h"
80 +#include "sysemu/block-backend.h"
82 +static unsigned char zero_vma_block[VMA_BLOCK_SIZE];
84 +typedef struct VmaRestoreState {
85 + BlockBackend *target;
87 + unsigned long *bitmap;
94 + GHashTable *blob_hash;
95 + unsigned char *head_data;
96 + VmaDeviceInfo devinfo[256];
97 + VmaRestoreState rstate[256];
99 + guint8 vmstate_stream;
100 + uint32_t vmstate_clusters;
101 + /* to show restore percentage if run with -v */
103 + int64_t cluster_count;
104 + int64_t clusters_read;
105 + int64_t zero_cluster_data;
106 + int64_t partial_zero_cluster_data;
107 + int clusters_read_per;
111 +g_int32_hash(gconstpointer v)
113 + return *(const uint32_t *)v;
117 +g_int32_equal(gconstpointer v1, gconstpointer v2)
119 + return *((const uint32_t *)v1) == *((const uint32_t *)v2);
122 +static int vma_reader_get_bitmap(VmaRestoreState *rstate, int64_t cluster_num)
125 + assert(rstate->bitmap);
127 + unsigned long val, idx, bit;
129 + idx = cluster_num / BITS_PER_LONG;
131 + assert(rstate->bitmap_size > idx);
133 + bit = cluster_num % BITS_PER_LONG;
134 + val = rstate->bitmap[idx];
136 + return !!(val & (1UL << bit));
139 +static void vma_reader_set_bitmap(VmaRestoreState *rstate, int64_t cluster_num,
143 + assert(rstate->bitmap);
145 + unsigned long val, idx, bit;
147 + idx = cluster_num / BITS_PER_LONG;
149 + assert(rstate->bitmap_size > idx);
151 + bit = cluster_num % BITS_PER_LONG;
152 + val = rstate->bitmap[idx];
154 + if (!(val & (1UL << bit))) {
158 + if (val & (1UL << bit)) {
159 + val &= ~(1UL << bit);
162 + rstate->bitmap[idx] = val;
165 +typedef struct VmaBlob {
171 +static const VmaBlob *get_header_blob(VmaReader *vmar, uint32_t pos)
174 + assert(vmar->blob_hash);
176 + return g_hash_table_lookup(vmar->blob_hash, &pos);
179 +static const char *get_header_str(VmaReader *vmar, uint32_t pos)
181 + const VmaBlob *blob = get_header_blob(vmar, pos);
185 + const char *res = (char *)blob->data;
186 + if (res[blob->len-1] != '\0') {
193 +safe_read(int fd, unsigned char *buf, size_t count)
198 + n = read(fd, buf, count);
199 + } while (n < 0 && errno == EINTR);
205 +full_read(int fd, unsigned char *buf, size_t len)
213 + n = safe_read(fd, buf, len);
235 +void vma_reader_destroy(VmaReader *vmar)
239 + if (vmar->fd >= 0) {
243 + if (vmar->cdata_list) {
244 + g_list_free(vmar->cdata_list);
248 + for (i = 1; i < 256; i++) {
249 + if (vmar->rstate[i].bitmap) {
250 + g_free(vmar->rstate[i].bitmap);
254 + if (vmar->md5csum) {
255 + g_checksum_free(vmar->md5csum);
258 + if (vmar->blob_hash) {
259 + g_hash_table_destroy(vmar->blob_hash);
262 + if (vmar->head_data) {
263 + g_free(vmar->head_data);
270 +static int vma_reader_read_head(VmaReader *vmar, Error **errp)
274 + assert(*errp == NULL);
276 + unsigned char md5sum[16];
280 + vmar->head_data = g_malloc(sizeof(VmaHeader));
282 + if (full_read(vmar->fd, vmar->head_data, sizeof(VmaHeader)) !=
283 + sizeof(VmaHeader)) {
284 + error_setg(errp, "can't read vma header - %s",
285 + errno ? g_strerror(errno) : "got EOF");
289 + VmaHeader *h = (VmaHeader *)vmar->head_data;
291 + if (h->magic != VMA_MAGIC) {
292 + error_setg(errp, "not a vma file - wrong magic number");
296 + uint32_t header_size = GUINT32_FROM_BE(h->header_size);
297 + int need = header_size - sizeof(VmaHeader);
299 + error_setg(errp, "wrong vma header size %d", header_size);
303 + vmar->head_data = g_realloc(vmar->head_data, header_size);
304 + h = (VmaHeader *)vmar->head_data;
306 + if (full_read(vmar->fd, vmar->head_data + sizeof(VmaHeader), need) !=
308 + error_setg(errp, "can't read vma header data - %s",
309 + errno ? g_strerror(errno) : "got EOF");
313 + memcpy(md5sum, h->md5sum, 16);
314 + memset(h->md5sum, 0, 16);
316 + g_checksum_reset(vmar->md5csum);
317 + g_checksum_update(vmar->md5csum, vmar->head_data, header_size);
319 + g_checksum_get_digest(vmar->md5csum, (guint8 *)(h->md5sum), &csize);
321 + if (memcmp(md5sum, h->md5sum, 16) != 0) {
322 + error_setg(errp, "wrong vma header chechsum");
326 + /* we can modify header data after checksum verify */
327 + h->header_size = header_size;
329 + h->version = GUINT32_FROM_BE(h->version);
330 + if (h->version != 1) {
331 + error_setg(errp, "wrong vma version %d", h->version);
335 + h->ctime = GUINT64_FROM_BE(h->ctime);
336 + h->blob_buffer_offset = GUINT32_FROM_BE(h->blob_buffer_offset);
337 + h->blob_buffer_size = GUINT32_FROM_BE(h->blob_buffer_size);
339 + uint32_t bstart = h->blob_buffer_offset + 1;
340 + uint32_t bend = h->blob_buffer_offset + h->blob_buffer_size;
342 + if (bstart <= sizeof(VmaHeader)) {
343 + error_setg(errp, "wrong vma blob buffer offset %d",
344 + h->blob_buffer_offset);
348 + if (bend > header_size) {
349 + error_setg(errp, "wrong vma blob buffer size %d/%d",
350 + h->blob_buffer_offset, h->blob_buffer_size);
354 + while ((bstart + 2) <= bend) {
355 + uint32_t size = vmar->head_data[bstart] +
356 + (vmar->head_data[bstart+1] << 8);
357 + if ((bstart + size + 2) <= bend) {
358 + VmaBlob *blob = g_new0(VmaBlob, 1);
359 + blob->start = bstart - h->blob_buffer_offset;
361 + blob->data = vmar->head_data + bstart + 2;
362 + g_hash_table_insert(vmar->blob_hash, &blob->start, blob);
364 + bstart += size + 2;
369 + for (i = 1; i < 256; i++) {
370 + VmaDeviceInfoHeader *dih = &h->dev_info[i];
371 + uint32_t devname_ptr = GUINT32_FROM_BE(dih->devname_ptr);
372 + uint64_t size = GUINT64_FROM_BE(dih->size);
373 + const char *devname = get_header_str(vmar, devname_ptr);
375 + if (size && devname) {
377 + vmar->devinfo[i].size = size;
378 + vmar->devinfo[i].devname = devname;
380 + if (strcmp(devname, "vmstate") == 0) {
381 + vmar->vmstate_stream = i;
386 + for (i = 0; i < VMA_MAX_CONFIGS; i++) {
387 + uint32_t name_ptr = GUINT32_FROM_BE(h->config_names[i]);
388 + uint32_t data_ptr = GUINT32_FROM_BE(h->config_data[i]);
390 + if (!(name_ptr && data_ptr)) {
393 + const char *name = get_header_str(vmar, name_ptr);
394 + const VmaBlob *blob = get_header_blob(vmar, data_ptr);
396 + if (!(name && blob)) {
397 + error_setg(errp, "vma contains invalid data pointers");
401 + VmaConfigData *cdata = g_new0(VmaConfigData, 1);
402 + cdata->name = name;
403 + cdata->data = blob->data;
404 + cdata->len = blob->len;
406 + vmar->cdata_list = g_list_append(vmar->cdata_list, cdata);
412 +VmaReader *vma_reader_create(const char *filename, Error **errp)
417 + VmaReader *vmar = g_new0(VmaReader, 1);
419 + if (strcmp(filename, "-") == 0) {
422 + vmar->fd = open(filename, O_RDONLY);
425 + if (vmar->fd < 0) {
426 + error_setg(errp, "can't open file %s - %s\n", filename,
427 + g_strerror(errno));
431 + vmar->md5csum = g_checksum_new(G_CHECKSUM_MD5);
432 + if (!vmar->md5csum) {
433 + error_setg(errp, "can't allocate cmsum\n");
437 + vmar->blob_hash = g_hash_table_new_full(g_int32_hash, g_int32_equal,
440 + if (vma_reader_read_head(vmar, errp) < 0) {
448 + vma_reader_destroy(vmar);
454 +VmaHeader *vma_reader_get_header(VmaReader *vmar)
457 + assert(vmar->head_data);
459 + return (VmaHeader *)(vmar->head_data);
462 +GList *vma_reader_get_config_data(VmaReader *vmar)
465 + assert(vmar->head_data);
467 + return vmar->cdata_list;
470 +VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id)
475 + if (vmar->devinfo[dev_id].size && vmar->devinfo[dev_id].devname) {
476 + return &vmar->devinfo[dev_id];
482 +static void allocate_rstate(VmaReader *vmar, guint8 dev_id,
483 + BlockBackend *target, bool write_zeroes)
488 + vmar->rstate[dev_id].target = target;
489 + vmar->rstate[dev_id].write_zeroes = write_zeroes;
491 + int64_t size = vmar->devinfo[dev_id].size;
493 + int64_t bitmap_size = (size/BDRV_SECTOR_SIZE) +
494 + (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG - 1;
495 + bitmap_size /= (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG;
497 + vmar->rstate[dev_id].bitmap_size = bitmap_size;
498 + vmar->rstate[dev_id].bitmap = g_new0(unsigned long, bitmap_size);
500 + vmar->cluster_count += size/VMA_CLUSTER_SIZE;
503 +int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockBackend *target,
504 + bool write_zeroes, Error **errp)
507 + assert(target != NULL);
509 + assert(vmar->rstate[dev_id].target == NULL);
511 + int64_t size = blk_getlength(target);
512 + int64_t size_diff = size - vmar->devinfo[dev_id].size;
514 + /* storage types can have different size restrictions, so it
515 + * is not always possible to create an image with exact size.
516 + * So we tolerate a size difference up to 4MB.
518 + if ((size_diff < 0) || (size_diff > 4*1024*1024)) {
519 + error_setg(errp, "vma_reader_register_bs for stream %s failed - "
520 + "unexpected size %zd != %zd", vmar->devinfo[dev_id].devname,
521 + size, vmar->devinfo[dev_id].size);
525 + allocate_rstate(vmar, dev_id, target, write_zeroes);
530 +static ssize_t safe_write(int fd, void *buf, size_t count)
535 + n = write(fd, buf, count);
536 + } while (n < 0 && errno == EINTR);
541 +static size_t full_write(int fd, void *buf, size_t len)
549 + n = safe_write(fd, buf, len);
559 + /* incomplete write ? */
566 +static int restore_write_data(VmaReader *vmar, guint8 dev_id,
567 + BlockBackend *target, int vmstate_fd,
568 + unsigned char *buf, int64_t sector_num,
569 + int nb_sectors, Error **errp)
573 + if (dev_id == vmar->vmstate_stream) {
574 + if (vmstate_fd >= 0) {
575 + int len = nb_sectors * BDRV_SECTOR_SIZE;
576 + int res = full_write(vmstate_fd, buf, len);
578 + error_setg(errp, "write vmstate failed %d", res);
583 + int res = blk_pwrite(target, sector_num * BDRV_SECTOR_SIZE, buf, nb_sectors * BDRV_SECTOR_SIZE, 0);
585 + error_setg(errp, "blk_pwrite to %s failed (%d)",
586 + bdrv_get_device_name(blk_bs(target)), res);
593 +static int restore_extent(VmaReader *vmar, unsigned char *buf,
594 + int extent_size, int vmstate_fd,
595 + bool verbose, bool verify, Error **errp)
600 + VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
601 + int start = VMA_EXTENT_HEADER_SIZE;
604 + for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
605 + uint64_t block_info = GUINT64_FROM_BE(ehead->blockinfo[i]);
606 + uint64_t cluster_num = block_info & 0xffffffff;
607 + uint8_t dev_id = (block_info >> 32) & 0xff;
608 + uint16_t mask = block_info >> (32+16);
609 + int64_t max_sector;
615 + VmaRestoreState *rstate = &vmar->rstate[dev_id];
616 + BlockBackend *target = NULL;
618 + if (dev_id != vmar->vmstate_stream) {
619 + target = rstate->target;
620 + if (!verify && !target) {
621 + error_setg(errp, "got wrong dev id %d", dev_id);
625 + if (vma_reader_get_bitmap(rstate, cluster_num)) {
626 + error_setg(errp, "found duplicated cluster %zd for stream %s",
627 + cluster_num, vmar->devinfo[dev_id].devname);
630 + vma_reader_set_bitmap(rstate, cluster_num, 1);
632 + max_sector = vmar->devinfo[dev_id].size/BDRV_SECTOR_SIZE;
634 + max_sector = G_MAXINT64;
635 + if (cluster_num != vmar->vmstate_clusters) {
636 + error_setg(errp, "found out of order vmstate data");
639 + vmar->vmstate_clusters++;
642 + vmar->clusters_read++;
645 + time_t duration = time(NULL) - vmar->start_time;
646 + int percent = (vmar->clusters_read*100)/vmar->cluster_count;
647 + if (percent != vmar->clusters_read_per) {
648 + printf("progress %d%% (read %zd bytes, duration %zd sec)\n",
649 + percent, vmar->clusters_read*VMA_CLUSTER_SIZE,
652 + vmar->clusters_read_per = percent;
656 + /* try to write whole clusters to speedup restore */
657 + if (mask == 0xffff) {
658 + if ((start + VMA_CLUSTER_SIZE) > extent_size) {
659 + error_setg(errp, "short vma extent - too many blocks");
662 + int64_t sector_num = (cluster_num * VMA_CLUSTER_SIZE) /
664 + int64_t end_sector = sector_num +
665 + VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE;
667 + if (end_sector > max_sector) {
668 + end_sector = max_sector;
671 + if (end_sector <= sector_num) {
672 + error_setg(errp, "got wrong block address - write beyond end");
677 + int nb_sectors = end_sector - sector_num;
678 + if (restore_write_data(vmar, dev_id, target, vmstate_fd,
679 + buf + start, sector_num, nb_sectors,
685 + start += VMA_CLUSTER_SIZE;
690 + for (j = 0; j < 16; j++) {
691 + int64_t sector_num = (cluster_num*VMA_CLUSTER_SIZE +
692 + j*VMA_BLOCK_SIZE)/BDRV_SECTOR_SIZE;
694 + int64_t end_sector = sector_num +
695 + VMA_BLOCK_SIZE/BDRV_SECTOR_SIZE;
696 + if (end_sector > max_sector) {
697 + end_sector = max_sector;
701 + if ((start + VMA_BLOCK_SIZE) > extent_size) {
702 + error_setg(errp, "short vma extent - too many blocks");
706 + if (end_sector <= sector_num) {
707 + error_setg(errp, "got wrong block address - "
708 + "write beyond end");
713 + int nb_sectors = end_sector - sector_num;
714 + if (restore_write_data(vmar, dev_id, target, vmstate_fd,
715 + buf + start, sector_num,
716 + nb_sectors, errp) < 0) {
721 + start += VMA_BLOCK_SIZE;
726 + if (end_sector > sector_num) {
727 + /* Todo: use bdrv_co_write_zeroes (but that need to
728 + * be run inside coroutine?)
730 + int nb_sectors = end_sector - sector_num;
731 + int zero_size = BDRV_SECTOR_SIZE*nb_sectors;
732 + vmar->zero_cluster_data += zero_size;
734 + vmar->partial_zero_cluster_data += zero_size;
737 + if (rstate->write_zeroes && !verify) {
738 + if (restore_write_data(vmar, dev_id, target, vmstate_fd,
739 + zero_vma_block, sector_num,
740 + nb_sectors, errp) < 0) {
752 + if (start != extent_size) {
753 + error_setg(errp, "vma extent error - missing blocks");
760 +static int vma_reader_restore_full(VmaReader *vmar, int vmstate_fd,
761 + bool verbose, bool verify,
765 + assert(vmar->head_data);
768 + unsigned char buf[VMA_MAX_EXTENT_SIZE];
770 + unsigned char md5sum[16];
771 + VmaHeader *h = (VmaHeader *)vmar->head_data;
773 + vmar->start_time = time(NULL);
776 + int bytes = full_read(vmar->fd, buf + buf_pos, sizeof(buf) - buf_pos);
778 + error_setg(errp, "read failed - %s", g_strerror(errno));
788 + if (buf_pos < VMA_EXTENT_HEADER_SIZE) {
789 + error_setg(errp, "read short extent (%d bytes)", buf_pos);
793 + VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
795 + /* extract md5sum */
796 + memcpy(md5sum, ehead->md5sum, sizeof(ehead->md5sum));
797 + memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
799 + g_checksum_reset(vmar->md5csum);
800 + g_checksum_update(vmar->md5csum, buf, VMA_EXTENT_HEADER_SIZE);
802 + g_checksum_get_digest(vmar->md5csum, ehead->md5sum, &csize);
804 + if (memcmp(md5sum, ehead->md5sum, 16) != 0) {
805 + error_setg(errp, "wrong vma extent header chechsum");
809 + if (memcmp(h->uuid, ehead->uuid, sizeof(ehead->uuid)) != 0) {
810 + error_setg(errp, "wrong vma extent uuid");
814 + if (ehead->magic != VMA_EXTENT_MAGIC || ehead->reserved1 != 0) {
815 + error_setg(errp, "wrong vma extent header magic");
819 + int block_count = GUINT16_FROM_BE(ehead->block_count);
820 + int extent_size = VMA_EXTENT_HEADER_SIZE + block_count*VMA_BLOCK_SIZE;
822 + if (buf_pos < extent_size) {
823 + error_setg(errp, "short vma extent (%d < %d)", buf_pos,
828 + if (restore_extent(vmar, buf, extent_size, vmstate_fd, verbose,
829 + verify, errp) < 0) {
833 + if (buf_pos > extent_size) {
834 + memmove(buf, buf + extent_size, buf_pos - extent_size);
835 + buf_pos = buf_pos - extent_size;
844 + for (i = 1; i < 256; i++) {
845 + VmaRestoreState *rstate = &vmar->rstate[i];
846 + if (!rstate->target) {
850 + if (blk_flush(rstate->target) < 0) {
851 + error_setg(errp, "vma blk_flush %s failed",
852 + vmar->devinfo[i].devname);
856 + if (vmar->devinfo[i].size &&
857 + (strcmp(vmar->devinfo[i].devname, "vmstate") != 0)) {
858 + assert(rstate->bitmap);
860 + int64_t cluster_num, end;
862 + end = (vmar->devinfo[i].size + VMA_CLUSTER_SIZE - 1) /
865 + for (cluster_num = 0; cluster_num < end; cluster_num++) {
866 + if (!vma_reader_get_bitmap(rstate, cluster_num)) {
867 + error_setg(errp, "detected missing cluster %zd "
868 + "for stream %s", cluster_num,
869 + vmar->devinfo[i].devname);
877 + if (vmar->clusters_read) {
878 + printf("total bytes read %zd, sparse bytes %zd (%.3g%%)\n",
879 + vmar->clusters_read*VMA_CLUSTER_SIZE,
880 + vmar->zero_cluster_data,
881 + (double)(100.0*vmar->zero_cluster_data)/
882 + (vmar->clusters_read*VMA_CLUSTER_SIZE));
884 + int64_t datasize = vmar->clusters_read*VMA_CLUSTER_SIZE-vmar->zero_cluster_data;
885 + if (datasize) { // this does not make sense for empty files
886 + printf("space reduction due to 4K zero blocks %.3g%%\n",
887 + (double)(100.0*vmar->partial_zero_cluster_data) / datasize);
890 + printf("vma archive contains no image data\n");
896 +int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
899 + return vma_reader_restore_full(vmar, vmstate_fd, verbose, false, errp);
902 +int vma_reader_verify(VmaReader *vmar, bool verbose, Error **errp)
906 + for (dev_id = 1; dev_id < 255; dev_id++) {
907 + if (vma_reader_get_device_info(vmar, dev_id)) {
908 + allocate_rstate(vmar, dev_id, NULL, false);
912 + return vma_reader_restore_full(vmar, -1, verbose, true, errp);
915 diff --git a/vma-writer.c b/vma-writer.c
917 index 0000000000..f5d2c5d23c
922 + * VMA: Virtual Machine Archive
924 + * Copyright (C) 2012 Proxmox Server Solutions
927 + * Dietmar Maurer (dietmar@proxmox.com)
929 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
930 + * See the COPYING file in the top-level directory.
934 +#include "qemu/osdep.h"
936 +#include <uuid/uuid.h>
939 +#include "block/block.h"
940 +#include "monitor/monitor.h"
941 +#include "qemu/main-loop.h"
942 +#include "qemu/coroutine.h"
943 +#include "qemu/cutils.h"
947 +#define DPRINTF(fmt, ...)\
948 + do { if (DEBUG_VMA) { printf("vma: " fmt, ## __VA_ARGS__); } } while (0)
950 +#define WRITE_BUFFERS 5
951 +#define HEADER_CLUSTERS 8
952 +#define HEADERBUF_SIZE (VMA_CLUSTER_SIZE*HEADER_CLUSTERS)
960 + bool header_written;
963 + /* we always write extents */
964 + unsigned char *outbuf;
965 + int outbuf_pos; /* in bytes */
966 + int outbuf_count; /* in VMA_BLOCKS */
967 + uint64_t outbuf_block_info[VMA_BLOCKS_PER_EXTENT];
969 + unsigned char *headerbuf;
971 + GChecksum *md5csum;
972 + CoMutex flush_lock;
973 + Coroutine *co_writer;
975 + /* drive informations */
976 + VmaStreamInfo stream_info[256];
977 + guint stream_count;
979 + guint8 vmstate_stream;
980 + uint32_t vmstate_clusters;
982 + /* header blob table */
983 + char *header_blob_table;
984 + uint32_t header_blob_table_size;
985 + uint32_t header_blob_table_pos;
987 + /* store for config blobs */
988 + uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
989 + uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
990 + uint32_t config_count;
993 +void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...)
997 + if (vmaw->status < 0) {
1001 + vmaw->status = -1;
1003 + va_start(ap, fmt);
1004 + g_vsnprintf(vmaw->errmsg, sizeof(vmaw->errmsg), fmt, ap);
1007 + DPRINTF("vma_writer_set_error: %s\n", vmaw->errmsg);
1010 +static uint32_t allocate_header_blob(VmaWriter *vmaw, const char *data,
1013 + if (len > 65535) {
1017 + if (!vmaw->header_blob_table ||
1018 + (vmaw->header_blob_table_size <
1019 + (vmaw->header_blob_table_pos + len + 2))) {
1020 + int newsize = vmaw->header_blob_table_size + ((len + 2 + 511)/512)*512;
1022 + vmaw->header_blob_table = g_realloc(vmaw->header_blob_table, newsize);
1023 + memset(vmaw->header_blob_table + vmaw->header_blob_table_size,
1024 + 0, newsize - vmaw->header_blob_table_size);
1025 + vmaw->header_blob_table_size = newsize;
1028 + uint32_t cpos = vmaw->header_blob_table_pos;
1029 + vmaw->header_blob_table[cpos] = len & 255;
1030 + vmaw->header_blob_table[cpos+1] = (len >> 8) & 255;
1031 + memcpy(vmaw->header_blob_table + cpos + 2, data, len);
1032 + vmaw->header_blob_table_pos += len + 2;
1036 +static uint32_t allocate_header_string(VmaWriter *vmaw, const char *str)
1040 + size_t len = strlen(str) + 1;
1042 + return allocate_header_blob(vmaw, str, len);
1045 +int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
1049 + assert(!vmaw->header_written);
1050 + assert(vmaw->config_count < VMA_MAX_CONFIGS);
1054 + gchar *basename = g_path_get_basename(name);
1055 + uint32_t name_ptr = allocate_header_string(vmaw, basename);
1062 + uint32_t data_ptr = allocate_header_blob(vmaw, data, len);
1067 + vmaw->config_names[vmaw->config_count] = name_ptr;
1068 + vmaw->config_data[vmaw->config_count] = data_ptr;
1070 + vmaw->config_count++;
1075 +int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
1080 + assert(!vmaw->status);
1082 + if (vmaw->header_written) {
1083 + vma_writer_set_error(vmaw, "vma_writer_register_stream: header "
1084 + "already written");
1088 + guint n = vmaw->stream_count + 1;
1090 + /* we can have dev_ids form 1 to 255 (0 reserved)
1091 + * 255(-1) reseverd for safety
1094 + vma_writer_set_error(vmaw, "vma_writer_register_stream: "
1095 + "too many drives");
1100 + vma_writer_set_error(vmaw, "vma_writer_register_stream: "
1101 + "got strange size %zd", size);
1105 + DPRINTF("vma_writer_register_stream %s %zu %d\n", devname, size, n);
1107 + vmaw->stream_info[n].devname = g_strdup(devname);
1108 + vmaw->stream_info[n].size = size;
1110 + vmaw->stream_info[n].cluster_count = (size + VMA_CLUSTER_SIZE - 1) /
1113 + vmaw->stream_count = n;
1115 + if (strcmp(devname, "vmstate") == 0) {
1116 + vmaw->vmstate_stream = n;
1122 +static void coroutine_fn yield_until_fd_writable(int fd)
1124 + assert(qemu_in_coroutine());
1125 + AioContext *ctx = qemu_get_current_aio_context();
1126 + aio_set_fd_handler(ctx, fd, false, NULL, (IOHandler *)qemu_coroutine_enter,
1127 + NULL, qemu_coroutine_self());
1128 + qemu_coroutine_yield();
1129 + aio_set_fd_handler(ctx, fd, false, NULL, NULL, NULL, NULL);
1132 +static ssize_t coroutine_fn
1133 +vma_queue_write(VmaWriter *vmaw, const void *buf, size_t bytes)
1135 + DPRINTF("vma_queue_write enter %zd\n", bytes);
1139 + assert(bytes <= VMA_MAX_EXTENT_SIZE);
1144 + assert(vmaw->co_writer == NULL);
1146 + vmaw->co_writer = qemu_coroutine_self();
1148 + while (done < bytes) {
1149 + if (vmaw->status < 0) {
1150 + DPRINTF("vma_queue_write detected canceled backup\n");
1154 + yield_until_fd_writable(vmaw->fd);
1155 + ret = write(vmaw->fd, buf + done, bytes - done);
1158 + DPRINTF("vma_queue_write written %zd %zd\n", done, ret);
1159 + } else if (ret < 0) {
1160 + if (errno == EAGAIN || errno == EWOULDBLOCK) {
1163 + vma_writer_set_error(vmaw, "vma_queue_write: write error - %s",
1164 + g_strerror(errno));
1165 + done = -1; /* always return failure for partial writes */
1168 + } else if (ret == 0) {
1169 + /* should not happen - simply try again */
1173 + vmaw->co_writer = NULL;
1175 + return (done == bytes) ? bytes : -1;
1178 +VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp)
1182 + assert(sizeof(VmaHeader) == (4096 + 8192));
1183 + assert(G_STRUCT_OFFSET(VmaHeader, config_names) == 2044);
1184 + assert(G_STRUCT_OFFSET(VmaHeader, config_data) == 3068);
1185 + assert(G_STRUCT_OFFSET(VmaHeader, dev_info) == 4096);
1186 + assert(sizeof(VmaExtentHeader) == 512);
1188 + VmaWriter *vmaw = g_new0(VmaWriter, 1);
1191 + vmaw->md5csum = g_checksum_new(G_CHECKSUM_MD5);
1192 + if (!vmaw->md5csum) {
1193 + error_setg(errp, "can't allocate cmsum\n");
1197 + if (strstart(filename, "exec:", &p)) {
1198 + vmaw->cmd = popen(p, "w");
1199 + if (vmaw->cmd == NULL) {
1200 + error_setg(errp, "can't popen command '%s' - %s\n", p,
1201 + g_strerror(errno));
1204 + vmaw->fd = fileno(vmaw->cmd);
1206 + /* try to use O_NONBLOCK */
1207 + fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
1212 + const char *tmp_id_str;
1214 + if ((stat(filename, &st) == 0) && S_ISFIFO(st.st_mode)) {
1215 + oflags = O_NONBLOCK|O_WRONLY;
1216 + vmaw->fd = qemu_open(filename, oflags, 0644);
1217 + } else if (strstart(filename, "/dev/fdset/", &tmp_id_str)) {
1218 + oflags = O_NONBLOCK|O_WRONLY;
1219 + vmaw->fd = qemu_open(filename, oflags, 0644);
1220 + } else if (strstart(filename, "/dev/fdname/", &tmp_id_str)) {
1221 + vmaw->fd = monitor_get_fd(cur_mon, tmp_id_str, errp);
1222 + if (vmaw->fd < 0) {
1225 + /* try to use O_NONBLOCK */
1226 + fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
1228 + oflags = O_NONBLOCK|O_DIRECT|O_WRONLY|O_CREAT|O_EXCL;
1229 + vmaw->fd = qemu_open(filename, oflags, 0644);
1232 + if (vmaw->fd < 0) {
1233 + error_setg(errp, "can't open file %s - %s\n", filename,
1234 + g_strerror(errno));
1239 + /* we use O_DIRECT, so we need to align IO buffers */
1241 + vmaw->outbuf = qemu_memalign(512, VMA_MAX_EXTENT_SIZE);
1242 + vmaw->headerbuf = qemu_memalign(512, HEADERBUF_SIZE);
1244 + vmaw->outbuf_count = 0;
1245 + vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
1247 + vmaw->header_blob_table_pos = 1; /* start at pos 1 */
1249 + qemu_co_mutex_init(&vmaw->flush_lock);
1251 + uuid_copy(vmaw->uuid, uuid);
1258 + pclose(vmaw->cmd);
1259 + } else if (vmaw->fd >= 0) {
1263 + if (vmaw->md5csum) {
1264 + g_checksum_free(vmaw->md5csum);
1273 +static int coroutine_fn vma_write_header(VmaWriter *vmaw)
1276 + unsigned char *buf = vmaw->headerbuf;
1277 + VmaHeader *head = (VmaHeader *)buf;
1281 + DPRINTF("VMA WRITE HEADER\n");
1283 + if (vmaw->status < 0) {
1284 + return vmaw->status;
1287 + memset(buf, 0, HEADERBUF_SIZE);
1289 + head->magic = VMA_MAGIC;
1290 + head->version = GUINT32_TO_BE(1); /* v1 */
1291 + memcpy(head->uuid, vmaw->uuid, 16);
1293 + time_t ctime = time(NULL);
1294 + head->ctime = GUINT64_TO_BE(ctime);
1296 + for (i = 0; i < VMA_MAX_CONFIGS; i++) {
1297 + head->config_names[i] = GUINT32_TO_BE(vmaw->config_names[i]);
1298 + head->config_data[i] = GUINT32_TO_BE(vmaw->config_data[i]);
1301 + /* 32 bytes per device (12 used currently) = 8192 bytes max */
1302 + for (i = 1; i <= 254; i++) {
1303 + VmaStreamInfo *si = &vmaw->stream_info[i];
1305 + assert(si->devname);
1306 + uint32_t devname_ptr = allocate_header_string(vmaw, si->devname);
1307 + if (!devname_ptr) {
1310 + head->dev_info[i].devname_ptr = GUINT32_TO_BE(devname_ptr);
1311 + head->dev_info[i].size = GUINT64_TO_BE(si->size);
1315 + uint32_t header_size = sizeof(VmaHeader) + vmaw->header_blob_table_size;
1316 + head->header_size = GUINT32_TO_BE(header_size);
1318 + if (header_size > HEADERBUF_SIZE) {
1319 + return -1; /* just to be sure */
1322 + uint32_t blob_buffer_offset = sizeof(VmaHeader);
1323 + memcpy(buf + blob_buffer_offset, vmaw->header_blob_table,
1324 + vmaw->header_blob_table_size);
1325 + head->blob_buffer_offset = GUINT32_TO_BE(blob_buffer_offset);
1326 + head->blob_buffer_size = GUINT32_TO_BE(vmaw->header_blob_table_pos);
1328 + g_checksum_reset(vmaw->md5csum);
1329 + g_checksum_update(vmaw->md5csum, (const guchar *)buf, header_size);
1331 + g_checksum_get_digest(vmaw->md5csum, (guint8 *)(head->md5sum), &csize);
1333 + return vma_queue_write(vmaw, buf, header_size);
1336 +static int coroutine_fn vma_writer_flush(VmaWriter *vmaw)
1343 + if (vmaw->status < 0) {
1344 + return vmaw->status;
1347 + if (!vmaw->header_written) {
1348 + vmaw->header_written = true;
1349 + ret = vma_write_header(vmaw);
1351 + vma_writer_set_error(vmaw, "vma_writer_flush: write header failed");
1356 + DPRINTF("VMA WRITE FLUSH %d %d\n", vmaw->outbuf_count, vmaw->outbuf_pos);
1359 + VmaExtentHeader *ehead = (VmaExtentHeader *)vmaw->outbuf;
1361 + ehead->magic = VMA_EXTENT_MAGIC;
1362 + ehead->reserved1 = 0;
1364 + for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
1365 + ehead->blockinfo[i] = GUINT64_TO_BE(vmaw->outbuf_block_info[i]);
1368 + guint16 block_count = (vmaw->outbuf_pos - VMA_EXTENT_HEADER_SIZE) /
1371 + ehead->block_count = GUINT16_TO_BE(block_count);
1373 + memcpy(ehead->uuid, vmaw->uuid, sizeof(ehead->uuid));
1374 + memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
1376 + g_checksum_reset(vmaw->md5csum);
1377 + g_checksum_update(vmaw->md5csum, vmaw->outbuf, VMA_EXTENT_HEADER_SIZE);
1379 + g_checksum_get_digest(vmaw->md5csum, ehead->md5sum, &csize);
1381 + int bytes = vmaw->outbuf_pos;
1382 + ret = vma_queue_write(vmaw, vmaw->outbuf, bytes);
1383 + if (ret != bytes) {
1384 + vma_writer_set_error(vmaw, "vma_writer_flush: failed write");
1387 + vmaw->outbuf_count = 0;
1388 + vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
1390 + for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
1391 + vmaw->outbuf_block_info[i] = 0;
1394 + return vmaw->status;
1397 +static int vma_count_open_streams(VmaWriter *vmaw)
1399 + g_assert(vmaw != NULL);
1402 + int open_drives = 0;
1403 + for (i = 0; i <= 255; i++) {
1404 + if (vmaw->stream_info[i].size && !vmaw->stream_info[i].finished) {
1409 + return open_drives;
1414 + * You need to call this if the vma archive does not contain
1415 + * any data stream.
1418 +vma_writer_flush_output(VmaWriter *vmaw)
1420 + qemu_co_mutex_lock(&vmaw->flush_lock);
1421 + int ret = vma_writer_flush(vmaw);
1422 + qemu_co_mutex_unlock(&vmaw->flush_lock);
1424 + vma_writer_set_error(vmaw, "vma_writer_flush_header failed");
1430 + * all jobs should call this when there is no more data
1431 + * Returns: number of remaining stream (0 ==> finished)
1434 +vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id)
1436 + g_assert(vmaw != NULL);
1438 + DPRINTF("vma_writer_set_status %d\n", dev_id);
1439 + if (!vmaw->stream_info[dev_id].size) {
1440 + vma_writer_set_error(vmaw, "vma_writer_close_stream: "
1441 + "no such stream %d", dev_id);
1444 + if (vmaw->stream_info[dev_id].finished) {
1445 + vma_writer_set_error(vmaw, "vma_writer_close_stream: "
1446 + "stream already closed %d", dev_id);
1450 + vmaw->stream_info[dev_id].finished = true;
1452 + int open_drives = vma_count_open_streams(vmaw);
1454 + if (open_drives <= 0) {
1455 + DPRINTF("vma_writer_set_status all drives completed\n");
1456 + vma_writer_flush_output(vmaw);
1459 + return open_drives;
1462 +int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status)
1466 + g_assert(vmaw != NULL);
1469 + status->status = vmaw->status;
1470 + g_strlcpy(status->errmsg, vmaw->errmsg, sizeof(status->errmsg));
1471 + for (i = 0; i <= 255; i++) {
1472 + status->stream_info[i] = vmaw->stream_info[i];
1475 + uuid_unparse_lower(vmaw->uuid, status->uuid_str);
1478 + status->closed = vmaw->closed;
1480 + return vmaw->status;
1483 +static int vma_writer_get_buffer(VmaWriter *vmaw)
1487 + qemu_co_mutex_lock(&vmaw->flush_lock);
1489 + /* wait until buffer is available */
1490 + while (vmaw->outbuf_count >= (VMA_BLOCKS_PER_EXTENT - 1)) {
1491 + ret = vma_writer_flush(vmaw);
1493 + vma_writer_set_error(vmaw, "vma_writer_get_buffer: flush failed");
1498 + qemu_co_mutex_unlock(&vmaw->flush_lock);
1504 +int64_t coroutine_fn
1505 +vma_writer_write(VmaWriter *vmaw, uint8_t dev_id, int64_t cluster_num,
1506 + const unsigned char *buf, size_t *zero_bytes)
1508 + g_assert(vmaw != NULL);
1509 + g_assert(zero_bytes != NULL);
1513 + if (vmaw->status < 0) {
1514 + return vmaw->status;
1517 + if (!dev_id || !vmaw->stream_info[dev_id].size) {
1518 + vma_writer_set_error(vmaw, "vma_writer_write: "
1519 + "no such stream %d", dev_id);
1523 + if (vmaw->stream_info[dev_id].finished) {
1524 + vma_writer_set_error(vmaw, "vma_writer_write: "
1525 + "stream already closed %d", dev_id);
1530 + if (cluster_num >= (((uint64_t)1)<<32)) {
1531 + vma_writer_set_error(vmaw, "vma_writer_write: "
1532 + "cluster number out of range");
1536 + if (dev_id == vmaw->vmstate_stream) {
1537 + if (cluster_num != vmaw->vmstate_clusters) {
1538 + vma_writer_set_error(vmaw, "vma_writer_write: "
1539 + "non sequential vmstate write");
1541 + vmaw->vmstate_clusters++;
1542 + } else if (cluster_num >= vmaw->stream_info[dev_id].cluster_count) {
1543 + vma_writer_set_error(vmaw, "vma_writer_write: cluster number too big");
1547 + /* wait until buffer is available */
1548 + if (vma_writer_get_buffer(vmaw) < 0) {
1549 + vma_writer_set_error(vmaw, "vma_writer_write: "
1550 + "vma_writer_get_buffer failed");
1554 + DPRINTF("VMA WRITE %d %zd\n", dev_id, cluster_num);
1556 + uint64_t dev_size = vmaw->stream_info[dev_id].size;
1557 + uint16_t mask = 0;
1562 + uint64_t byte_offset = cluster_num * VMA_CLUSTER_SIZE;
1563 + for (i = 0; i < 16; i++) {
1564 + const unsigned char *vmablock = buf + (i*VMA_BLOCK_SIZE);
1566 + // Note: If the source is not 64k-aligned, we might reach 4k blocks
1567 + // after the end of the device. Always mark these as zero in the
1568 + // mask, so the restore handles them correctly.
1569 + if (byte_offset < dev_size &&
1570 + !buffer_is_zero(vmablock, VMA_BLOCK_SIZE))
1573 + memcpy(vmaw->outbuf + vmaw->outbuf_pos, vmablock,
1576 + // prevent memory leakage on unaligned last block
1577 + if (byte_offset + VMA_BLOCK_SIZE > dev_size) {
1578 + uint64_t real_data_in_block = dev_size - byte_offset;
1579 + memset(vmaw->outbuf + vmaw->outbuf_pos + real_data_in_block,
1580 + 0, VMA_BLOCK_SIZE - real_data_in_block);
1583 + vmaw->outbuf_pos += VMA_BLOCK_SIZE;
1585 + DPRINTF("VMA WRITE %zd ZERO BLOCK %d\n", cluster_num, i);
1586 + vmaw->stream_info[dev_id].zero_bytes += VMA_BLOCK_SIZE;
1587 + *zero_bytes += VMA_BLOCK_SIZE;
1590 + byte_offset += VMA_BLOCK_SIZE;
1594 + DPRINTF("VMA WRITE %zd ZERO CLUSTER\n", cluster_num);
1595 + vmaw->stream_info[dev_id].zero_bytes += VMA_CLUSTER_SIZE;
1596 + *zero_bytes += VMA_CLUSTER_SIZE;
1599 + uint64_t block_info = ((uint64_t)mask) << (32+16);
1600 + block_info |= ((uint64_t)dev_id) << 32;
1601 + block_info |= (cluster_num & 0xffffffff);
1602 + vmaw->outbuf_block_info[vmaw->outbuf_count] = block_info;
1604 + DPRINTF("VMA WRITE MASK %zd %zx\n", cluster_num, block_info);
1606 + vmaw->outbuf_count++;
1608 + /** NOTE: We allways write whole clusters, but we correctly set
1609 + * transferred bytes. So transferred == size when when everything
1612 + size_t transferred = VMA_CLUSTER_SIZE;
1614 + if (dev_id != vmaw->vmstate_stream) {
1615 + uint64_t last = (cluster_num + 1) * VMA_CLUSTER_SIZE;
1616 + if (last > dev_size) {
1617 + uint64_t diff = last - dev_size;
1618 + if (diff >= VMA_CLUSTER_SIZE) {
1619 + vma_writer_set_error(vmaw, "vma_writer_write: "
1620 + "read after last cluster");
1623 + transferred -= diff;
1627 + vmaw->stream_info[dev_id].transferred += transferred;
1629 + return transferred;
1632 +void vma_writer_error_propagate(VmaWriter *vmaw, Error **errp)
1634 + if (vmaw->status < 0 && *errp == NULL) {
1635 + error_setg(errp, "%s", vmaw->errmsg);
1639 +int vma_writer_close(VmaWriter *vmaw, Error **errp)
1641 + g_assert(vmaw != NULL);
1645 + qemu_co_mutex_lock(&vmaw->flush_lock); // wait for pending writes
1647 + assert(vmaw->co_writer == NULL);
1650 + if (pclose(vmaw->cmd) < 0) {
1651 + vma_writer_set_error(vmaw, "vma_writer_close: "
1652 + "pclose failed - %s", g_strerror(errno));
1655 + if (close(vmaw->fd) < 0) {
1656 + vma_writer_set_error(vmaw, "vma_writer_close: "
1657 + "close failed - %s", g_strerror(errno));
1661 + for (i = 0; i <= 255; i++) {
1662 + VmaStreamInfo *si = &vmaw->stream_info[i];
1664 + if (!si->finished) {
1665 + vma_writer_set_error(vmaw, "vma_writer_close: "
1666 + "detected open stream '%s'", si->devname);
1667 + } else if ((si->transferred != si->size) &&
1668 + (i != vmaw->vmstate_stream)) {
1669 + vma_writer_set_error(vmaw, "vma_writer_close: "
1670 + "incomplete stream '%s' (%zd != %zd)",
1671 + si->devname, si->transferred, si->size);
1676 + for (i = 0; i <= 255; i++) {
1677 + vmaw->stream_info[i].finished = 1; /* mark as closed */
1682 + if (vmaw->status < 0 && *errp == NULL) {
1683 + error_setg(errp, "%s", vmaw->errmsg);
1686 + qemu_co_mutex_unlock(&vmaw->flush_lock);
1688 + return vmaw->status;
1691 +void vma_writer_destroy(VmaWriter *vmaw)
1697 + for (i = 0; i <= 255; i++) {
1698 + if (vmaw->stream_info[i].devname) {
1699 + g_free(vmaw->stream_info[i].devname);
1703 + if (vmaw->md5csum) {
1704 + g_checksum_free(vmaw->md5csum);
1707 + qemu_vfree(vmaw->headerbuf);
1708 + qemu_vfree(vmaw->outbuf);
1711 diff --git a/vma.c b/vma.c
1712 new file mode 100644
1713 index 0000000000..2eea2fc281
1718 + * VMA: Virtual Machine Archive
1720 + * Copyright (C) 2012-2013 Proxmox Server Solutions
1723 + * Dietmar Maurer (dietmar@proxmox.com)
1725 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
1726 + * See the COPYING file in the top-level directory.
1730 +#include "qemu/osdep.h"
1734 +#include "qemu-common.h"
1735 +#include "qemu/module.h"
1736 +#include "qemu/error-report.h"
1737 +#include "qemu/main-loop.h"
1738 +#include "qemu/cutils.h"
1739 +#include "qapi/qmp/qdict.h"
1740 +#include "sysemu/block-backend.h"
1742 +static void help(void)
1744 + const char *help_msg =
1745 + "usage: vma command [command options]\n"
1747 + "vma list <filename>\n"
1748 + "vma config <filename> [-c config]\n"
1749 + "vma create <filename> [-c config] pathname ...\n"
1750 + "vma extract <filename> [-r <fifo>] <targetdir>\n"
1751 + "vma verify <filename> [-v]\n"
1754 + printf("%s", help_msg);
1758 +static const char *extract_devname(const char *path, char **devname, int index)
1762 + const char *sep = strchr(path, '=');
1765 + *devname = g_strndup(path, sep - path);
1769 + *devname = g_strdup_printf("disk%d", index);
1778 +static void print_content(VmaReader *vmar)
1782 + VmaHeader *head = vma_reader_get_header(vmar);
1784 + GList *l = vma_reader_get_config_data(vmar);
1785 + while (l && l->data) {
1786 + VmaConfigData *cdata = (VmaConfigData *)l->data;
1787 + l = g_list_next(l);
1788 + printf("CFG: size: %d name: %s\n", cdata->len, cdata->name);
1792 + VmaDeviceInfo *di;
1793 + for (i = 1; i < 255; i++) {
1794 + di = vma_reader_get_device_info(vmar, i);
1796 + if (strcmp(di->devname, "vmstate") == 0) {
1797 + printf("VMSTATE: dev_id=%d memory: %zd\n", i, di->size);
1799 + printf("DEV: dev_id=%d size: %zd devname: %s\n",
1800 + i, di->size, di->devname);
1804 + /* ctime is the last entry we print */
1805 + printf("CTIME: %s", ctime(&head->ctime));
1809 +static int list_content(int argc, char **argv)
1812 + const char *filename;
1815 + c = getopt(argc, argv, "h");
1825 + g_assert_not_reached();
1829 + /* Get the filename */
1830 + if ((optind + 1) != argc) {
1833 + filename = argv[optind++];
1835 + Error *errp = NULL;
1836 + VmaReader *vmar = vma_reader_create(filename, &errp);
1839 + g_error("%s", error_get_pretty(errp));
1842 + print_content(vmar);
1844 + vma_reader_destroy(vmar);
1849 +typedef struct RestoreMap {
1853 + uint64_t throttling_bps;
1854 + char *throttling_group;
1859 +static bool try_parse_option(char **line, const char *optname, char **out, const char *inbuf) {
1860 + size_t optlen = strlen(optname);
1861 + if (strncmp(*line, optname, optlen) != 0 || (*line)[optlen] != '=') {
1865 + g_error("read map failed - duplicate value for option '%s'", optname);
1867 + char *value = (*line) + optlen + 1; /* including a '=' */
1868 + char *colon = strchr(value, ':');
1870 + g_error("read map failed - option '%s' not terminated ('%s')",
1874 + *out = g_strndup(value, colon - value);
1878 +static uint64_t verify_u64(const char *text) {
1880 + const char *endptr = NULL;
1881 + if (qemu_strtou64(text, &endptr, 0, &value) != 0 || !endptr || *endptr) {
1882 + g_error("read map failed - not a number: %s", text);
1887 +static int extract_content(int argc, char **argv)
1891 + const char *filename;
1892 + const char *dirname;
1893 + const char *readmap = NULL;
1896 + c = getopt(argc, argv, "hvr:");
1916 + /* Get the filename */
1917 + if ((optind + 2) != argc) {
1920 + filename = argv[optind++];
1921 + dirname = argv[optind++];
1923 + Error *errp = NULL;
1924 + VmaReader *vmar = vma_reader_create(filename, &errp);
1927 + g_error("%s", error_get_pretty(errp));
1930 + if (mkdir(dirname, 0777) < 0) {
1931 + g_error("unable to create target directory %s - %s",
1932 + dirname, g_strerror(errno));
1935 + GList *l = vma_reader_get_config_data(vmar);
1936 + while (l && l->data) {
1937 + VmaConfigData *cdata = (VmaConfigData *)l->data;
1938 + l = g_list_next(l);
1939 + char *cfgfn = g_strdup_printf("%s/%s", dirname, cdata->name);
1940 + GError *err = NULL;
1941 + if (!g_file_set_contents(cfgfn, (gchar *)cdata->data, cdata->len,
1943 + g_error("unable to write file: %s", err->message);
1947 + GHashTable *devmap = g_hash_table_new(g_str_hash, g_str_equal);
1950 + print_content(vmar);
1952 + FILE *map = fopen(readmap, "r");
1954 + g_error("unable to open fifo %s - %s", readmap, g_strerror(errno));
1959 + char *line = fgets(inbuf, sizeof(inbuf), map);
1960 + char *format = NULL;
1962 + char *group = NULL;
1963 + char *cache = NULL;
1964 + if (!line || line[0] == '\0' || !strcmp(line, "done\n")) {
1967 + int len = strlen(line);
1968 + if (line[len - 1] == '\n') {
1969 + line[len - 1] = '\0';
1976 + if (!try_parse_option(&line, "format", &format, inbuf) &&
1977 + !try_parse_option(&line, "throttling.bps", &bps, inbuf) &&
1978 + !try_parse_option(&line, "throttling.group", &group, inbuf) &&
1979 + !try_parse_option(&line, "cache", &cache, inbuf))
1985 + uint64_t bps_value = 0;
1987 + bps_value = verify_u64(bps);
1993 + if (line[0] == '0' && line[1] == ':') {
1995 + write_zero = false;
1996 + } else if (line[0] == '1' && line[1] == ':') {
1998 + write_zero = true;
2000 + g_error("read map failed - parse error ('%s')", inbuf);
2003 + char *devname = NULL;
2004 + path = extract_devname(path, &devname, -1);
2006 + g_error("read map failed - no dev name specified ('%s')",
2010 + RestoreMap *map = g_new0(RestoreMap, 1);
2011 + map->devname = g_strdup(devname);
2012 + map->path = g_strdup(path);
2013 + map->format = format;
2014 + map->throttling_bps = bps_value;
2015 + map->throttling_group = group;
2016 + map->cache = cache;
2017 + map->write_zero = write_zero;
2019 + g_hash_table_insert(devmap, map->devname, map);
2025 + int vmstate_fd = -1;
2026 + guint8 vmstate_stream = 0;
2028 + BlockBackend *blk = NULL;
2030 + for (i = 1; i < 255; i++) {
2031 + VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
2032 + if (di && (strcmp(di->devname, "vmstate") == 0)) {
2033 + vmstate_stream = i;
2034 + char *statefn = g_strdup_printf("%s/vmstate.bin", dirname);
2035 + vmstate_fd = open(statefn, O_WRONLY|O_CREAT|O_EXCL, 0644);
2036 + if (vmstate_fd < 0) {
2037 + g_error("create vmstate file '%s' failed - %s", statefn,
2038 + g_strerror(errno));
2042 + char *devfn = NULL;
2043 + const char *format = NULL;
2044 + uint64_t throttling_bps = 0;
2045 + const char *throttling_group = NULL;
2046 + const char *cache = NULL;
2047 + int flags = BDRV_O_RDWR;
2048 + bool write_zero = true;
2052 + map = (RestoreMap *)g_hash_table_lookup(devmap, di->devname);
2053 + if (map == NULL) {
2054 + g_error("no device name mapping for %s", di->devname);
2056 + devfn = map->path;
2057 + format = map->format;
2058 + throttling_bps = map->throttling_bps;
2059 + throttling_group = map->throttling_group;
2060 + cache = map->cache;
2061 + write_zero = map->write_zero;
2063 + devfn = g_strdup_printf("%s/tmp-disk-%s.raw",
2064 + dirname, di->devname);
2065 + printf("DEVINFO %s %zd\n", devfn, di->size);
2067 + bdrv_img_create(devfn, "raw", NULL, NULL, NULL, di->size,
2068 + flags, true, &errp);
2070 + g_error("can't create file %s: %s", devfn,
2071 + error_get_pretty(errp));
2074 + /* Note: we created an empty file above, so there is no
2075 + * need to write zeroes (so we generate a sparse file)
2077 + write_zero = false;
2080 + size_t devlen = strlen(devfn);
2081 + QDict *options = NULL;
2082 + bool writethrough;
2084 + /* explicit format from commandline */
2085 + options = qdict_new();
2086 + qdict_put_str(options, "driver", format);
2087 + } else if ((devlen > 4 && strcmp(devfn+devlen-4, ".raw") == 0) ||
2088 + strncmp(devfn, "/dev/", 5) == 0)
2090 + /* This part is now deprecated for PVE as well (just as qemu
2091 + * deprecated not specifying an explicit raw format, too.
2093 + /* explicit raw format */
2094 + options = qdict_new();
2095 + qdict_put_str(options, "driver", "raw");
2097 + if (cache && bdrv_parse_cache_mode(cache, &flags, &writethrough)) {
2098 + g_error("invalid cache option: %s\n", cache);
2101 + if (errp || !(blk = blk_new_open(devfn, NULL, options, flags, &errp))) {
2102 + g_error("can't open file %s - %s", devfn,
2103 + error_get_pretty(errp));
2107 + blk_set_enable_write_cache(blk, !writethrough);
2110 + if (throttling_group) {
2111 + blk_io_limits_enable(blk, throttling_group);
2114 + if (throttling_bps) {
2115 + if (!throttling_group) {
2116 + blk_io_limits_enable(blk, devfn);
2119 + ThrottleConfig cfg;
2120 + throttle_config_init(&cfg);
2121 + cfg.buckets[THROTTLE_BPS_WRITE].avg = throttling_bps;
2122 + Error *err = NULL;
2123 + if (!throttle_is_valid(&cfg, &err)) {
2124 + error_report_err(err);
2125 + g_error("failed to apply throttling");
2127 + blk_set_io_limits(blk, &cfg);
2130 + if (vma_reader_register_bs(vmar, i, blk, write_zero, &errp) < 0) {
2131 + g_error("%s", error_get_pretty(errp));
2140 + if (vma_reader_restore(vmar, vmstate_fd, verbose, &errp) < 0) {
2141 + g_error("restore failed - %s", error_get_pretty(errp));
2145 + for (i = 1; i < 255; i++) {
2146 + VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
2147 + if (di && (i != vmstate_stream)) {
2148 + char *tmpfn = g_strdup_printf("%s/tmp-disk-%s.raw",
2149 + dirname, di->devname);
2150 + char *fn = g_strdup_printf("%s/disk-%s.raw",
2151 + dirname, di->devname);
2152 + if (rename(tmpfn, fn) != 0) {
2153 + g_error("rename %s to %s failed - %s",
2154 + tmpfn, fn, g_strerror(errno));
2160 + vma_reader_destroy(vmar);
2169 +static int verify_content(int argc, char **argv)
2173 + const char *filename;
2176 + c = getopt(argc, argv, "hv");
2193 + /* Get the filename */
2194 + if ((optind + 1) != argc) {
2197 + filename = argv[optind++];
2199 + Error *errp = NULL;
2200 + VmaReader *vmar = vma_reader_create(filename, &errp);
2203 + g_error("%s", error_get_pretty(errp));
2207 + print_content(vmar);
2210 + if (vma_reader_verify(vmar, verbose, &errp) < 0) {
2211 + g_error("verify failed - %s", error_get_pretty(errp));
2214 + vma_reader_destroy(vmar);
2221 +typedef struct BackupJob {
2222 + BlockBackend *target;
2228 +#define BACKUP_SECTORS_PER_CLUSTER (VMA_CLUSTER_SIZE / BDRV_SECTOR_SIZE)
2230 +static void coroutine_fn backup_run_empty(void *opaque)
2232 + VmaWriter *vmaw = (VmaWriter *)opaque;
2234 + vma_writer_flush_output(vmaw);
2236 + Error *err = NULL;
2237 + if (vma_writer_close(vmaw, &err) != 0) {
2238 + g_warning("vma_writer_close failed %s", error_get_pretty(err));
2242 +static void coroutine_fn backup_run(void *opaque)
2244 + BackupJob *job = (BackupJob *)opaque;
2246 + QEMUIOVector qiov;
2248 + int64_t start, end;
2251 + unsigned char *buf = blk_blockalign(job->target, VMA_CLUSTER_SIZE);
2254 + end = DIV_ROUND_UP(job->len / BDRV_SECTOR_SIZE,
2255 + BACKUP_SECTORS_PER_CLUSTER);
2257 + for (; start < end; start++) {
2258 + iov.iov_base = buf;
2259 + iov.iov_len = VMA_CLUSTER_SIZE;
2260 + qemu_iovec_init_external(&qiov, &iov, 1);
2262 + ret = blk_co_preadv(job->target, start * VMA_CLUSTER_SIZE,
2263 + VMA_CLUSTER_SIZE, &qiov, 0);
2265 + vma_writer_set_error(job->vmaw, "read error", -1);
2270 + if (vma_writer_write(job->vmaw, job->dev_id, start, buf, &zb) < 0) {
2271 + vma_writer_set_error(job->vmaw, "backup_dump_cb vma_writer_write failed", -1);
2278 + if (vma_writer_close_stream(job->vmaw, job->dev_id) <= 0) {
2279 + Error *err = NULL;
2280 + if (vma_writer_close(job->vmaw, &err) != 0) {
2281 + g_warning("vma_writer_close failed %s", error_get_pretty(err));
2287 +static int create_archive(int argc, char **argv)
2291 + const char *archivename;
2292 + GList *config_files = NULL;
2295 + c = getopt(argc, argv, "hvc:");
2305 + config_files = g_list_append(config_files, optarg);
2311 + g_assert_not_reached();
2316 + /* make sure we an archive name */
2317 + if ((optind + 1) > argc) {
2321 + archivename = argv[optind++];
2324 + uuid_generate(uuid);
2326 + Error *local_err = NULL;
2327 + VmaWriter *vmaw = vma_writer_create(archivename, uuid, &local_err);
2329 + if (vmaw == NULL) {
2330 + g_error("%s", error_get_pretty(local_err));
2333 + GList *l = config_files;
2334 + while (l && l->data) {
2335 + char *name = l->data;
2336 + char *cdata = NULL;
2338 + GError *err = NULL;
2339 + if (!g_file_get_contents(name, &cdata, &clen, &err)) {
2340 + unlink(archivename);
2341 + g_error("Unable to read file: %s", err->message);
2344 + if (vma_writer_add_config(vmaw, name, cdata, clen) != 0) {
2345 + unlink(archivename);
2346 + g_error("Unable to append config data %s (len = %zd)",
2349 + l = g_list_next(l);
2353 + while (optind < argc) {
2354 + const char *path = argv[optind++];
2355 + char *devname = NULL;
2356 + path = extract_devname(path, &devname, devcount++);
2358 + Error *errp = NULL;
2359 + BlockBackend *target;
2361 + target = blk_new_open(path, NULL, NULL, 0, &errp);
2363 + unlink(archivename);
2364 + g_error("bdrv_open '%s' failed - %s", path, error_get_pretty(errp));
2366 + int64_t size = blk_getlength(target);
2367 + int dev_id = vma_writer_register_stream(vmaw, devname, size);
2368 + if (dev_id <= 0) {
2369 + unlink(archivename);
2370 + g_error("vma_writer_register_stream '%s' failed", devname);
2373 + BackupJob *job = g_new0(BackupJob, 1);
2375 + job->target = target;
2377 + job->dev_id = dev_id;
2379 + Coroutine *co = qemu_coroutine_create(backup_run, job);
2380 + qemu_coroutine_enter(co);
2383 + VmaStatus vmastat;
2385 + int last_percent = -1;
2389 + main_loop_wait(false);
2390 + vma_writer_get_status(vmaw, &vmastat);
2394 + uint64_t total = 0;
2395 + uint64_t transferred = 0;
2396 + uint64_t zero_bytes = 0;
2399 + for (i = 0; i < 256; i++) {
2400 + if (vmastat.stream_info[i].size) {
2401 + total += vmastat.stream_info[i].size;
2402 + transferred += vmastat.stream_info[i].transferred;
2403 + zero_bytes += vmastat.stream_info[i].zero_bytes;
2406 + percent = (transferred*100)/total;
2407 + if (percent != last_percent) {
2408 + fprintf(stderr, "progress %d%% %zd/%zd %zd\n", percent,
2409 + transferred, total, zero_bytes);
2412 + last_percent = percent;
2416 + if (vmastat.closed) {
2421 + Coroutine *co = qemu_coroutine_create(backup_run_empty, vmaw);
2422 + qemu_coroutine_enter(co);
2424 + main_loop_wait(false);
2425 + vma_writer_get_status(vmaw, &vmastat);
2426 + if (vmastat.closed) {
2434 + vma_writer_get_status(vmaw, &vmastat);
2437 + for (i = 0; i < 256; i++) {
2438 + VmaStreamInfo *si = &vmastat.stream_info[i];
2440 + fprintf(stderr, "image %s: size=%zd zeros=%zd saved=%zd\n",
2441 + si->devname, si->size, si->zero_bytes,
2442 + si->size - si->zero_bytes);
2447 + if (vmastat.status < 0) {
2448 + unlink(archivename);
2449 + g_error("creating vma archive failed");
2452 + vma_writer_destroy(vmaw);
2456 +static int dump_config(int argc, char **argv)
2459 + const char *filename;
2460 + const char *config_name = "qemu-server.conf";
2463 + c = getopt(argc, argv, "hc:");
2473 + config_name = optarg;
2480 + /* Get the filename */
2481 + if ((optind + 1) != argc) {
2484 + filename = argv[optind++];
2486 + Error *errp = NULL;
2487 + VmaReader *vmar = vma_reader_create(filename, &errp);
2490 + g_error("%s", error_get_pretty(errp));
2494 + GList *l = vma_reader_get_config_data(vmar);
2495 + while (l && l->data) {
2496 + VmaConfigData *cdata = (VmaConfigData *)l->data;
2497 + l = g_list_next(l);
2498 + if (strcmp(cdata->name, config_name) == 0) {
2500 + fwrite(cdata->data, cdata->len, 1, stdout);
2505 + vma_reader_destroy(vmar);
2510 + fprintf(stderr, "unable to find configuration data '%s'\n", config_name);
2517 +int main(int argc, char **argv)
2519 + const char *cmdname;
2520 + Error *main_loop_err = NULL;
2522 + error_init(argv[0]);
2523 + module_call_init(MODULE_INIT_TRACE);
2524 + qemu_init_exec_dir(argv[0]);
2526 + if (qemu_init_main_loop(&main_loop_err)) {
2527 + g_error("%s", error_get_pretty(main_loop_err));
2531 + module_call_init(MODULE_INIT_QOM);
2537 + cmdname = argv[1];
2541 + if (!strcmp(cmdname, "list")) {
2542 + return list_content(argc, argv);
2543 + } else if (!strcmp(cmdname, "create")) {
2544 + return create_archive(argc, argv);
2545 + } else if (!strcmp(cmdname, "extract")) {
2546 + return extract_content(argc, argv);
2547 + } else if (!strcmp(cmdname, "verify")) {
2548 + return verify_content(argc, argv);
2549 + } else if (!strcmp(cmdname, "config")) {
2550 + return dump_config(argc, argv);
2556 diff --git a/vma.h b/vma.h
2557 new file mode 100644
2558 index 0000000000..c895c97f6d
2563 + * VMA: Virtual Machine Archive
2565 + * Copyright (C) Proxmox Server Solutions
2568 + * Dietmar Maurer (dietmar@proxmox.com)
2570 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
2571 + * See the COPYING file in the top-level directory.
2575 +#ifndef BACKUP_VMA_H
2576 +#define BACKUP_VMA_H
2578 +#include <uuid/uuid.h>
2579 +#include "qapi/error.h"
2580 +#include "block/block.h"
2582 +#define VMA_BLOCK_BITS 12
2583 +#define VMA_BLOCK_SIZE (1<<VMA_BLOCK_BITS)
2584 +#define VMA_CLUSTER_BITS (VMA_BLOCK_BITS+4)
2585 +#define VMA_CLUSTER_SIZE (1<<VMA_CLUSTER_BITS)
2587 +#if VMA_CLUSTER_SIZE != 65536
2588 +#error unexpected cluster size
2591 +#define VMA_EXTENT_HEADER_SIZE 512
2592 +#define VMA_BLOCKS_PER_EXTENT 59
2593 +#define VMA_MAX_CONFIGS 256
2595 +#define VMA_MAX_EXTENT_SIZE \
2596 + (VMA_EXTENT_HEADER_SIZE+VMA_CLUSTER_SIZE*VMA_BLOCKS_PER_EXTENT)
2597 +#if VMA_MAX_EXTENT_SIZE != 3867136
2598 +#error unexpected VMA_EXTENT_SIZE
2601 +/* File Format Definitions */
2603 +#define VMA_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|0x00))
2604 +#define VMA_EXTENT_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|'E'))
2606 +typedef struct VmaDeviceInfoHeader {
2607 + uint32_t devname_ptr; /* offset into blob_buffer table */
2608 + uint32_t reserved0;
2609 + uint64_t size; /* device size in bytes */
2610 + uint64_t reserved1;
2611 + uint64_t reserved2;
2612 +} VmaDeviceInfoHeader;
2614 +typedef struct VmaHeader {
2617 + unsigned char uuid[16];
2619 + unsigned char md5sum[16];
2621 + uint32_t blob_buffer_offset;
2622 + uint32_t blob_buffer_size;
2623 + uint32_t header_size;
2625 + unsigned char reserved[1984];
2627 + uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
2628 + uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
2630 + uint32_t reserved1;
2632 + VmaDeviceInfoHeader dev_info[256];
2635 +typedef struct VmaExtentHeader {
2637 + uint16_t reserved1;
2638 + uint16_t block_count;
2639 + unsigned char uuid[16];
2640 + unsigned char md5sum[16];
2641 + uint64_t blockinfo[VMA_BLOCKS_PER_EXTENT];
2644 +/* functions/definitions to read/write vma files */
2646 +typedef struct VmaReader VmaReader;
2648 +typedef struct VmaWriter VmaWriter;
2650 +typedef struct VmaConfigData {
2656 +typedef struct VmaStreamInfo {
2658 + uint64_t cluster_count;
2659 + uint64_t transferred;
2660 + uint64_t zero_bytes;
2665 +typedef struct VmaStatus {
2668 + char errmsg[8192];
2669 + char uuid_str[37];
2670 + VmaStreamInfo stream_info[256];
2673 +typedef struct VmaDeviceInfo {
2674 + uint64_t size; /* device size in bytes */
2675 + const char *devname;
2678 +VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp);
2679 +int vma_writer_close(VmaWriter *vmaw, Error **errp);
2680 +void vma_writer_error_propagate(VmaWriter *vmaw, Error **errp);
2681 +void vma_writer_destroy(VmaWriter *vmaw);
2682 +int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
2684 +int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
2687 +int64_t coroutine_fn vma_writer_write(VmaWriter *vmaw, uint8_t dev_id,
2688 + int64_t cluster_num,
2689 + const unsigned char *buf,
2690 + size_t *zero_bytes);
2692 +int coroutine_fn vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id);
2693 +int coroutine_fn vma_writer_flush_output(VmaWriter *vmaw);
2695 +int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status);
2696 +void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...);
2699 +VmaReader *vma_reader_create(const char *filename, Error **errp);
2700 +void vma_reader_destroy(VmaReader *vmar);
2701 +VmaHeader *vma_reader_get_header(VmaReader *vmar);
2702 +GList *vma_reader_get_config_data(VmaReader *vmar);
2703 +VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id);
2704 +int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id,
2705 + BlockBackend *target, bool write_zeroes,
2707 +int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
2709 +int vma_reader_verify(VmaReader *vmar, bool verbose, Error **errp);
2711 +#endif /* BACKUP_VMA_H */