| blob | 3e0fab32365efa9382f0ed4b6116f15e3e4d0d64 |
1 From 04b6468a295871877b55fe792c566839e2afe29c Mon Sep 17 00:00:00 2001
2 From: Dietmar Maurer <dietmar@proxmox.com>
3 Date: Tue, 13 Nov 2012 11:11:38 +0100
4 Subject: [PATCH 11/41] introduce new vma archive format
6 This is a very simple archive format, see docs/specs/vma_spec.txt
8 Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
9 ---
10 Makefile | 3 +-
11 Makefile.objs | 1 +
12 vma-reader.c | 799 ++++++++++++++++++++++++++++++++++++++++++++++++++++
13 vma-writer.c | 876 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
14 vma.c | 582 ++++++++++++++++++++++++++++++++++++++
15 vma.h | 146 ++++++++++
16 6 files changed, 2406 insertions(+), 1 deletion(-)
17 create mode 100644 vma-reader.c
18 create mode 100644 vma-writer.c
19 create mode 100644 vma.c
20 create mode 100644 vma.h
22 diff --git a/Makefile b/Makefile
23 index 930ac27..6cedc40 100644
24 --- a/Makefile
25 +++ b/Makefile
26 @@ -166,7 +166,7 @@ ifneq ($(wildcard config-host.mak),)
27 include $(SRC_PATH)/tests/Makefile
28 endif
30 -all: $(DOCS) $(TOOLS) $(HELPERS-y) recurse-all modules
31 +all: $(DOCS) $(TOOLS) vma$(EXESUF) $(HELPERS-y) recurse-all modules
33 config-host.h: config-host.h-timestamp
34 config-host.h-timestamp: config-host.mak
35 @@ -235,6 +235,7 @@ qemu-img.o: qemu-img-cmds.h
36 qemu-img$(EXESUF): qemu-img.o $(block-obj-y) $(crypto-obj-y) $(qom-obj-y) libqemuutil.a libqemustub.a
37 qemu-nbd$(EXESUF): qemu-nbd.o $(block-obj-y) $(crypto-obj-y) $(qom-obj-y) libqemuutil.a libqemustub.a
38 qemu-io$(EXESUF): qemu-io.o $(block-obj-y) $(crypto-obj-y) $(qom-obj-y) libqemuutil.a libqemustub.a
39 +vma$(EXESUF): vma.o vma-reader.o $(block-obj-y) $(crypto-obj-y) $(qom-obj-y) libqemuutil.a libqemustub.a
41 qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o
43 diff --git a/Makefile.objs b/Makefile.objs
44 index 77be052..97d2bcc 100644
45 --- a/Makefile.objs
46 +++ b/Makefile.objs
47 @@ -14,6 +14,7 @@ block-obj-$(CONFIG_POSIX) += aio-posix.o
48 block-obj-$(CONFIG_WIN32) += aio-win32.o
49 block-obj-y += block/
50 block-obj-y += qemu-io-cmds.o
51 +block-obj-y += vma-writer.o
53 block-obj-m = block/
55 diff --git a/vma-reader.c b/vma-reader.c
56 new file mode 100644
57 index 0000000..bc36cba
58 --- /dev/null
59 +++ b/vma-reader.c
60 @@ -0,0 +1,799 @@
61 +/*
62 + * VMA: Virtual Machine Archive
63 + *
64 + * Copyright (C) 2012 Proxmox Server Solutions
65 + *
66 + * Authors:
67 + * Dietmar Maurer (dietmar@proxmox.com)
68 + *
69 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
70 + * See the COPYING file in the top-level directory.
71 + *
72 + */
73 +
74 +#include <stdio.h>
75 +#include <errno.h>
76 +#include <unistd.h>
77 +#include <stdio.h>
78 +#include <string.h>
79 +#include <sys/types.h>
80 +#include <sys/stat.h>
81 +#include <fcntl.h>
82 +#include <glib.h>
83 +#include <uuid/uuid.h>
84 +
85 +#include "qemu-common.h"
86 +#include "qemu/timer.h"
87 +#include "qemu/ratelimit.h"
88 +#include "vma.h"
89 +#include "block/block.h"
90 +
91 +#define BITS_PER_LONG (sizeof(unsigned long) * CHAR_BIT)
92 +
93 +static unsigned char zero_vma_block[VMA_BLOCK_SIZE];
94 +
95 +typedef struct VmaRestoreState {
96 + BlockDriverState *bs;
97 + bool write_zeroes;
98 + unsigned long *bitmap;
99 + int bitmap_size;
100 +} VmaRestoreState;
101 +
102 +struct VmaReader {
103 + int fd;
104 + GChecksum *md5csum;
105 + GHashTable *blob_hash;
106 + unsigned char *head_data;
107 + VmaDeviceInfo devinfo[256];
108 + VmaRestoreState rstate[256];
109 + GList *cdata_list;
110 + guint8 vmstate_stream;
111 + uint32_t vmstate_clusters;
112 + /* to show restore percentage if run with -v */
113 + time_t start_time;
114 + int64_t cluster_count;
115 + int64_t clusters_read;
116 + int clusters_read_per;
117 +};
118 +
119 +static guint
120 +g_int32_hash(gconstpointer v)
121 +{
122 + return *(const uint32_t *)v;
123 +}
124 +
125 +static gboolean
126 +g_int32_equal(gconstpointer v1, gconstpointer v2)
127 +{
128 + return *((const uint32_t *)v1) == *((const uint32_t *)v2);
129 +}
130 +
131 +static int vma_reader_get_bitmap(VmaRestoreState *rstate, int64_t cluster_num)
132 +{
133 + assert(rstate);
134 + assert(rstate->bitmap);
135 +
136 + unsigned long val, idx, bit;
137 +
138 + idx = cluster_num / BITS_PER_LONG;
139 +
140 + assert(rstate->bitmap_size > idx);
141 +
142 + bit = cluster_num % BITS_PER_LONG;
143 + val = rstate->bitmap[idx];
144 +
145 + return !!(val & (1UL << bit));
146 +}
147 +
148 +static void vma_reader_set_bitmap(VmaRestoreState *rstate, int64_t cluster_num,
149 + int dirty)
150 +{
151 + assert(rstate);
152 + assert(rstate->bitmap);
153 +
154 + unsigned long val, idx, bit;
155 +
156 + idx = cluster_num / BITS_PER_LONG;
157 +
158 + assert(rstate->bitmap_size > idx);
159 +
160 + bit = cluster_num % BITS_PER_LONG;
161 + val = rstate->bitmap[idx];
162 + if (dirty) {
163 + if (!(val & (1UL << bit))) {
164 + val |= 1UL << bit;
165 + }
166 + } else {
167 + if (val & (1UL << bit)) {
168 + val &= ~(1UL << bit);
169 + }
170 + }
171 + rstate->bitmap[idx] = val;
172 +}
173 +
174 +typedef struct VmaBlob {
175 + uint32_t start;
176 + uint32_t len;
177 + void *data;
178 +} VmaBlob;
179 +
180 +static const VmaBlob *get_header_blob(VmaReader *vmar, uint32_t pos)
181 +{
182 + assert(vmar);
183 + assert(vmar->blob_hash);
184 +
185 + return g_hash_table_lookup(vmar->blob_hash, &pos);
186 +}
187 +
188 +static const char *get_header_str(VmaReader *vmar, uint32_t pos)
189 +{
190 + const VmaBlob *blob = get_header_blob(vmar, pos);
191 + if (!blob) {
192 + return NULL;
193 + }
194 + const char *res = (char *)blob->data;
195 + if (res[blob->len-1] != '\0') {
196 + return NULL;
197 + }
198 + return res;
199 +}
200 +
201 +static ssize_t
202 +safe_read(int fd, unsigned char *buf, size_t count)
203 +{
204 + ssize_t n;
205 +
206 + do {
207 + n = read(fd, buf, count);
208 + } while (n < 0 && errno == EINTR);
209 +
210 + return n;
211 +}
212 +
213 +static ssize_t
214 +full_read(int fd, unsigned char *buf, size_t len)
215 +{
216 + ssize_t n;
217 + size_t total;
218 +
219 + total = 0;
220 +
221 + while (len > 0) {
222 + n = safe_read(fd, buf, len);
223 +
224 + if (n == 0) {
225 + return total;
226 + }
227 +
228 + if (n <= 0) {
229 + break;
230 + }
231 +
232 + buf += n;
233 + total += n;
234 + len -= n;
235 + }
236 +
237 + if (len) {
238 + return -1;
239 + }
240 +
241 + return total;
242 +}
243 +
244 +void vma_reader_destroy(VmaReader *vmar)
245 +{
246 + assert(vmar);
247 +
248 + if (vmar->fd >= 0) {
249 + close(vmar->fd);
250 + }
251 +
252 + if (vmar->cdata_list) {
253 + g_list_free(vmar->cdata_list);
254 + }
255 +
256 + int i;
257 + for (i = 1; i < 256; i++) {
258 + if (vmar->rstate[i].bitmap) {
259 + g_free(vmar->rstate[i].bitmap);
260 + }
261 + }
262 +
263 + if (vmar->md5csum) {
264 + g_checksum_free(vmar->md5csum);
265 + }
266 +
267 + if (vmar->blob_hash) {
268 + g_hash_table_destroy(vmar->blob_hash);
269 + }
270 +
271 + if (vmar->head_data) {
272 + g_free(vmar->head_data);
273 + }
274 +
275 + g_free(vmar);
276 +
277 +};
278 +
279 +static int vma_reader_read_head(VmaReader *vmar, Error **errp)
280 +{
281 + assert(vmar);
282 + assert(errp);
283 + assert(*errp == NULL);
284 +
285 + unsigned char md5sum[16];
286 + int i;
287 + int ret = 0;
288 +
289 + vmar->head_data = g_malloc(sizeof(VmaHeader));
290 +
291 + if (full_read(vmar->fd, vmar->head_data, sizeof(VmaHeader)) !=
292 + sizeof(VmaHeader)) {
293 + error_setg(errp, "can't read vma header - %s",
294 + errno ? g_strerror(errno) : "got EOF");
295 + return -1;
296 + }
297 +
298 + VmaHeader *h = (VmaHeader *)vmar->head_data;
299 +
300 + if (h->magic != VMA_MAGIC) {
301 + error_setg(errp, "not a vma file - wrong magic number");
302 + return -1;
303 + }
304 +
305 + uint32_t header_size = GUINT32_FROM_BE(h->header_size);
306 + int need = header_size - sizeof(VmaHeader);
307 + if (need <= 0) {
308 + error_setg(errp, "wrong vma header size %d", header_size);
309 + return -1;
310 + }
311 +
312 + vmar->head_data = g_realloc(vmar->head_data, header_size);
313 + h = (VmaHeader *)vmar->head_data;
314 +
315 + if (full_read(vmar->fd, vmar->head_data + sizeof(VmaHeader), need) !=
316 + need) {
317 + error_setg(errp, "can't read vma header data - %s",
318 + errno ? g_strerror(errno) : "got EOF");
319 + return -1;
320 + }
321 +
322 + memcpy(md5sum, h->md5sum, 16);
323 + memset(h->md5sum, 0, 16);
324 +
325 + g_checksum_reset(vmar->md5csum);
326 + g_checksum_update(vmar->md5csum, vmar->head_data, header_size);
327 + gsize csize = 16;
328 + g_checksum_get_digest(vmar->md5csum, (guint8 *)(h->md5sum), &csize);
329 +
330 + if (memcmp(md5sum, h->md5sum, 16) != 0) {
331 + error_setg(errp, "wrong vma header chechsum");
332 + return -1;
333 + }
334 +
335 + /* we can modify header data after checksum verify */
336 + h->header_size = header_size;
337 +
338 + h->version = GUINT32_FROM_BE(h->version);
339 + if (h->version != 1) {
340 + error_setg(errp, "wrong vma version %d", h->version);
341 + return -1;
342 + }
343 +
344 + h->ctime = GUINT64_FROM_BE(h->ctime);
345 + h->blob_buffer_offset = GUINT32_FROM_BE(h->blob_buffer_offset);
346 + h->blob_buffer_size = GUINT32_FROM_BE(h->blob_buffer_size);
347 +
348 + uint32_t bstart = h->blob_buffer_offset + 1;
349 + uint32_t bend = h->blob_buffer_offset + h->blob_buffer_size;
350 +
351 + if (bstart <= sizeof(VmaHeader)) {
352 + error_setg(errp, "wrong vma blob buffer offset %d",
353 + h->blob_buffer_offset);
354 + return -1;
355 + }
356 +
357 + if (bend > header_size) {
358 + error_setg(errp, "wrong vma blob buffer size %d/%d",
359 + h->blob_buffer_offset, h->blob_buffer_size);
360 + return -1;
361 + }
362 +
363 + while ((bstart + 2) <= bend) {
364 + uint32_t size = vmar->head_data[bstart] +
365 + (vmar->head_data[bstart+1] << 8);
366 + if ((bstart + size + 2) <= bend) {
367 + VmaBlob *blob = g_new0(VmaBlob, 1);
368 + blob->start = bstart - h->blob_buffer_offset;
369 + blob->len = size;
370 + blob->data = vmar->head_data + bstart + 2;
371 + g_hash_table_insert(vmar->blob_hash, &blob->start, blob);
372 + }
373 + bstart += size + 2;
374 + }
375 +
376 +
377 + int count = 0;
378 + for (i = 1; i < 256; i++) {
379 + VmaDeviceInfoHeader *dih = &h->dev_info[i];
380 + uint32_t devname_ptr = GUINT32_FROM_BE(dih->devname_ptr);
381 + uint64_t size = GUINT64_FROM_BE(dih->size);
382 + const char *devname = get_header_str(vmar, devname_ptr);
383 +
384 + if (size && devname) {
385 + count++;
386 + vmar->devinfo[i].size = size;
387 + vmar->devinfo[i].devname = devname;
388 +
389 + if (strcmp(devname, "vmstate") == 0) {
390 + vmar->vmstate_stream = i;
391 + }
392 + }
393 + }
394 +
395 + if (!count) {
396 + error_setg(errp, "vma does not contain data");
397 + return -1;
398 + }
399 +
400 + for (i = 0; i < VMA_MAX_CONFIGS; i++) {
401 + uint32_t name_ptr = GUINT32_FROM_BE(h->config_names[i]);
402 + uint32_t data_ptr = GUINT32_FROM_BE(h->config_data[i]);
403 +
404 + if (!(name_ptr && data_ptr)) {
405 + continue;
406 + }
407 + const char *name = get_header_str(vmar, name_ptr);
408 + const VmaBlob *blob = get_header_blob(vmar, data_ptr);
409 +
410 + if (!(name && blob)) {
411 + error_setg(errp, "vma contains invalid data pointers");
412 + return -1;
413 + }
414 +
415 + VmaConfigData *cdata = g_new0(VmaConfigData, 1);
416 + cdata->name = name;
417 + cdata->data = blob->data;
418 + cdata->len = blob->len;
419 +
420 + vmar->cdata_list = g_list_append(vmar->cdata_list, cdata);
421 + }
422 +
423 + return ret;
424 +};
425 +
426 +VmaReader *vma_reader_create(const char *filename, Error **errp)
427 +{
428 + assert(filename);
429 + assert(errp);
430 +
431 + VmaReader *vmar = g_new0(VmaReader, 1);
432 +
433 + if (strcmp(filename, "-") == 0) {
434 + vmar->fd = dup(0);
435 + } else {
436 + vmar->fd = open(filename, O_RDONLY);
437 + }
438 +
439 + if (vmar->fd < 0) {
440 + error_setg(errp, "can't open file %s - %s\n", filename,
441 + g_strerror(errno));
442 + goto err;
443 + }
444 +
445 + vmar->md5csum = g_checksum_new(G_CHECKSUM_MD5);
446 + if (!vmar->md5csum) {
447 + error_setg(errp, "can't allocate cmsum\n");
448 + goto err;
449 + }
450 +
451 + vmar->blob_hash = g_hash_table_new_full(g_int32_hash, g_int32_equal,
452 + NULL, g_free);
453 +
454 + if (vma_reader_read_head(vmar, errp) < 0) {
455 + goto err;
456 + }
457 +
458 + return vmar;
459 +
460 +err:
461 + if (vmar) {
462 + vma_reader_destroy(vmar);
463 + }
464 +
465 + return NULL;
466 +}
467 +
468 +VmaHeader *vma_reader_get_header(VmaReader *vmar)
469 +{
470 + assert(vmar);
471 + assert(vmar->head_data);
472 +
473 + return (VmaHeader *)(vmar->head_data);
474 +}
475 +
476 +GList *vma_reader_get_config_data(VmaReader *vmar)
477 +{
478 + assert(vmar);
479 + assert(vmar->head_data);
480 +
481 + return vmar->cdata_list;
482 +}
483 +
484 +VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id)
485 +{
486 + assert(vmar);
487 + assert(dev_id);
488 +
489 + if (vmar->devinfo[dev_id].size && vmar->devinfo[dev_id].devname) {
490 + return &vmar->devinfo[dev_id];
491 + }
492 +
493 + return NULL;
494 +}
495 +
496 +int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockDriverState *bs,
497 + bool write_zeroes, Error **errp)
498 +{
499 + assert(vmar);
500 + assert(bs != NULL);
501 + assert(dev_id);
502 + assert(vmar->rstate[dev_id].bs == NULL);
503 +
504 + int64_t size = bdrv_getlength(bs);
505 + if (size != vmar->devinfo[dev_id].size) {
506 + error_setg(errp, "vma_reader_register_bs for stream %s failed - "
507 + "unexpected size %zd != %zd", vmar->devinfo[dev_id].devname,
508 + size, vmar->devinfo[dev_id].size);
509 + return -1;
510 + }
511 +
512 + vmar->rstate[dev_id].bs = bs;
513 + vmar->rstate[dev_id].write_zeroes = write_zeroes;
514 +
515 + int64_t bitmap_size = (size/BDRV_SECTOR_SIZE) +
516 + (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG - 1;
517 + bitmap_size /= (VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE) * BITS_PER_LONG;
518 +
519 + vmar->rstate[dev_id].bitmap_size = bitmap_size;
520 + vmar->rstate[dev_id].bitmap = g_new0(unsigned long, bitmap_size);
521 +
522 + vmar->cluster_count += size/VMA_CLUSTER_SIZE;
523 +
524 + return 0;
525 +}
526 +
527 +static ssize_t safe_write(int fd, void *buf, size_t count)
528 +{
529 + ssize_t n;
530 +
531 + do {
532 + n = write(fd, buf, count);
533 + } while (n < 0 && errno == EINTR);
534 +
535 + return n;
536 +}
537 +
538 +static size_t full_write(int fd, void *buf, size_t len)
539 +{
540 + ssize_t n;
541 + size_t total;
542 +
543 + total = 0;
544 +
545 + while (len > 0) {
546 + n = safe_write(fd, buf, len);
547 + if (n < 0) {
548 + return n;
549 + }
550 + buf += n;
551 + total += n;
552 + len -= n;
553 + }
554 +
555 + if (len) {
556 + /* incomplete write ? */
557 + return -1;
558 + }
559 +
560 + return total;
561 +}
562 +
563 +static int restore_write_data(VmaReader *vmar, guint8 dev_id,
564 + BlockDriverState *bs, int vmstate_fd,
565 + unsigned char *buf, int64_t sector_num,
566 + int nb_sectors, Error **errp)
567 +{
568 + assert(vmar);
569 +
570 + if (dev_id == vmar->vmstate_stream) {
571 + if (vmstate_fd >= 0) {
572 + int len = nb_sectors * BDRV_SECTOR_SIZE;
573 + int res = full_write(vmstate_fd, buf, len);
574 + if (res < 0) {
575 + error_setg(errp, "write vmstate failed %d", res);
576 + return -1;
577 + }
578 + }
579 + } else {
580 + int res = bdrv_write(bs, sector_num, buf, nb_sectors);
581 + if (res < 0) {
582 + error_setg(errp, "bdrv_write to %s failed (%d)",
583 + bdrv_get_device_name(bs), res);
584 + return -1;
585 + }
586 + }
587 + return 0;
588 +}
589 +static int restore_extent(VmaReader *vmar, unsigned char *buf,
590 + int extent_size, int vmstate_fd,
591 + bool verbose, Error **errp)
592 +{
593 + assert(vmar);
594 + assert(buf);
595 +
596 + VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
597 + int start = VMA_EXTENT_HEADER_SIZE;
598 + int i;
599 +
600 + for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
601 + uint64_t block_info = GUINT64_FROM_BE(ehead->blockinfo[i]);
602 + uint64_t cluster_num = block_info & 0xffffffff;
603 + uint8_t dev_id = (block_info >> 32) & 0xff;
604 + uint16_t mask = block_info >> (32+16);
605 + int64_t max_sector;
606 +
607 + if (!dev_id) {
608 + continue;
609 + }
610 +
611 + VmaRestoreState *rstate = &vmar->rstate[dev_id];
612 + BlockDriverState *bs = NULL;
613 +
614 + if (dev_id != vmar->vmstate_stream) {
615 + bs = rstate->bs;
616 + if (!bs) {
617 + error_setg(errp, "got wrong dev id %d", dev_id);
618 + return -1;
619 + }
620 +
621 + if (vma_reader_get_bitmap(rstate, cluster_num)) {
622 + error_setg(errp, "found duplicated cluster %zd for stream %s",
623 + cluster_num, vmar->devinfo[dev_id].devname);
624 + return -1;
625 + }
626 + vma_reader_set_bitmap(rstate, cluster_num, 1);
627 +
628 + max_sector = vmar->devinfo[dev_id].size/BDRV_SECTOR_SIZE;
629 + } else {
630 + max_sector = G_MAXINT64;
631 + if (cluster_num != vmar->vmstate_clusters) {
632 + error_setg(errp, "found out of order vmstate data");
633 + return -1;
634 + }
635 + vmar->vmstate_clusters++;
636 + }
637 +
638 + vmar->clusters_read++;
639 +
640 + if (verbose) {
641 + time_t duration = time(NULL) - vmar->start_time;
642 + int percent = (vmar->clusters_read*100)/vmar->cluster_count;
643 + if (percent != vmar->clusters_read_per) {
644 + printf("progress %d%% (read %zd bytes, duration %zd sec)\n",
645 + percent, vmar->clusters_read*VMA_CLUSTER_SIZE,
646 + duration);
647 + fflush(stdout);
648 + vmar->clusters_read_per = percent;
649 + }
650 + }
651 +
652 + /* try to write whole clusters to speedup restore */
653 + if (mask == 0xffff) {
654 + if ((start + VMA_CLUSTER_SIZE) > extent_size) {
655 + error_setg(errp, "short vma extent - too many blocks");
656 + return -1;
657 + }
658 + int64_t sector_num = (cluster_num * VMA_CLUSTER_SIZE) /
659 + BDRV_SECTOR_SIZE;
660 + int64_t end_sector = sector_num +
661 + VMA_CLUSTER_SIZE/BDRV_SECTOR_SIZE;
662 +
663 + if (end_sector > max_sector) {
664 + end_sector = max_sector;
665 + }
666 +
667 + if (end_sector <= sector_num) {
668 + error_setg(errp, "got wrong block address - write bejond end");
669 + return -1;
670 + }
671 +
672 + int nb_sectors = end_sector - sector_num;
673 + if (restore_write_data(vmar, dev_id, bs, vmstate_fd, buf + start,
674 + sector_num, nb_sectors, errp) < 0) {
675 + return -1;
676 + }
677 +
678 + start += VMA_CLUSTER_SIZE;
679 + } else {
680 + int j;
681 + int bit = 1;
682 +
683 + for (j = 0; j < 16; j++) {
684 + int64_t sector_num = (cluster_num*VMA_CLUSTER_SIZE +
685 + j*VMA_BLOCK_SIZE)/BDRV_SECTOR_SIZE;
686 +
687 + int64_t end_sector = sector_num +
688 + VMA_BLOCK_SIZE/BDRV_SECTOR_SIZE;
689 + if (end_sector > max_sector) {
690 + end_sector = max_sector;
691 + }
692 +
693 + if (mask & bit) {
694 + if ((start + VMA_BLOCK_SIZE) > extent_size) {
695 + error_setg(errp, "short vma extent - too many blocks");
696 + return -1;
697 + }
698 +
699 + if (end_sector <= sector_num) {
700 + error_setg(errp, "got wrong block address - "
701 + "write bejond end");
702 + return -1;
703 + }
704 +
705 + int nb_sectors = end_sector - sector_num;
706 + if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
707 + buf + start, sector_num,
708 + nb_sectors, errp) < 0) {
709 + return -1;
710 + }
711 +
712 + start += VMA_BLOCK_SIZE;
713 +
714 + } else {
715 +
716 + if (rstate->write_zeroes && (end_sector > sector_num)) {
717 + /* Todo: use bdrv_co_write_zeroes (but that need to
718 + * be run inside coroutine?)
719 + */
720 + int nb_sectors = end_sector - sector_num;
721 + if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
722 + zero_vma_block, sector_num,
723 + nb_sectors, errp) < 0) {
724 + return -1;
725 + }
726 + }
727 + }
728 +
729 + bit = bit << 1;
730 + }
731 + }
732 + }
733 +
734 + if (start != extent_size) {
735 + error_setg(errp, "vma extent error - missing blocks");
736 + return -1;
737 + }
738 +
739 + return 0;
740 +}
741 +
742 +int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
743 + Error **errp)
744 +{
745 + assert(vmar);
746 + assert(vmar->head_data);
747 +
748 + int ret = 0;
749 + unsigned char buf[VMA_MAX_EXTENT_SIZE];
750 + int buf_pos = 0;
751 + unsigned char md5sum[16];
752 + VmaHeader *h = (VmaHeader *)vmar->head_data;
753 +
754 + vmar->start_time = time(NULL);
755 +
756 + while (1) {
757 + int bytes = full_read(vmar->fd, buf + buf_pos, sizeof(buf) - buf_pos);
758 + if (bytes < 0) {
759 + error_setg(errp, "read failed - %s", g_strerror(errno));
760 + return -1;
761 + }
762 +
763 + buf_pos += bytes;
764 +
765 + if (!buf_pos) {
766 + break; /* EOF */
767 + }
768 +
769 + if (buf_pos < VMA_EXTENT_HEADER_SIZE) {
770 + error_setg(errp, "read short extent (%d bytes)", buf_pos);
771 + return -1;
772 + }
773 +
774 + VmaExtentHeader *ehead = (VmaExtentHeader *)buf;
775 +
776 + /* extract md5sum */
777 + memcpy(md5sum, ehead->md5sum, sizeof(ehead->md5sum));
778 + memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
779 +
780 + g_checksum_reset(vmar->md5csum);
781 + g_checksum_update(vmar->md5csum, buf, VMA_EXTENT_HEADER_SIZE);
782 + gsize csize = 16;
783 + g_checksum_get_digest(vmar->md5csum, ehead->md5sum, &csize);
784 +
785 + if (memcmp(md5sum, ehead->md5sum, 16) != 0) {
786 + error_setg(errp, "wrong vma extent header chechsum");
787 + return -1;
788 + }
789 +
790 + if (memcmp(h->uuid, ehead->uuid, sizeof(ehead->uuid)) != 0) {
791 + error_setg(errp, "wrong vma extent uuid");
792 + return -1;
793 + }
794 +
795 + if (ehead->magic != VMA_EXTENT_MAGIC || ehead->reserved1 != 0) {
796 + error_setg(errp, "wrong vma extent header magic");
797 + return -1;
798 + }
799 +
800 + int block_count = GUINT16_FROM_BE(ehead->block_count);
801 + int extent_size = VMA_EXTENT_HEADER_SIZE + block_count*VMA_BLOCK_SIZE;
802 +
803 + if (buf_pos < extent_size) {
804 + error_setg(errp, "short vma extent (%d < %d)", buf_pos,
805 + extent_size);
806 + return -1;
807 + }
808 +
809 + if (restore_extent(vmar, buf, extent_size, vmstate_fd, verbose,
810 + errp) < 0) {
811 + return -1;
812 + }
813 +
814 + if (buf_pos > extent_size) {
815 + memmove(buf, buf + extent_size, buf_pos - extent_size);
816 + buf_pos = buf_pos - extent_size;
817 + } else {
818 + buf_pos = 0;
819 + }
820 + }
821 +
822 + bdrv_drain_all();
823 +
824 + int i;
825 + for (i = 1; i < 256; i++) {
826 + VmaRestoreState *rstate = &vmar->rstate[i];
827 + if (!rstate->bs) {
828 + continue;
829 + }
830 +
831 + if (bdrv_flush(rstate->bs) < 0) {
832 + error_setg(errp, "vma bdrv_flush %s failed",
833 + vmar->devinfo[i].devname);
834 + return -1;
835 + }
836 +
837 + if (vmar->devinfo[i].size &&
838 + (strcmp(vmar->devinfo[i].devname, "vmstate") != 0)) {
839 + assert(rstate->bitmap);
840 +
841 + int64_t cluster_num, end;
842 +
843 + end = (vmar->devinfo[i].size + VMA_CLUSTER_SIZE - 1) /
844 + VMA_CLUSTER_SIZE;
845 +
846 + for (cluster_num = 0; cluster_num < end; cluster_num++) {
847 + if (!vma_reader_get_bitmap(rstate, cluster_num)) {
848 + error_setg(errp, "detected missing cluster %zd "
849 + "for stream %s", cluster_num,
850 + vmar->devinfo[i].devname);
851 + return -1;
852 + }
853 + }
854 + }
855 + }
856 +
857 + return ret;
858 +}
859 +
860 diff --git a/vma-writer.c b/vma-writer.c
861 new file mode 100644
862 index 0000000..8a3fa1c
863 --- /dev/null
864 +++ b/vma-writer.c
865 @@ -0,0 +1,876 @@
866 +/*
867 + * VMA: Virtual Machine Archive
868 + *
869 + * Copyright (C) 2012 Proxmox Server Solutions
870 + *
871 + * Authors:
872 + * Dietmar Maurer (dietmar@proxmox.com)
873 + *
874 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
875 + * See the COPYING file in the top-level directory.
876 + *
877 + */
878 +
879 +#include <stdio.h>
880 +#include <errno.h>
881 +#include <unistd.h>
882 +#include <stdio.h>
883 +#include <string.h>
884 +#include <sys/types.h>
885 +#include <sys/stat.h>
886 +#include <fcntl.h>
887 +#include <glib.h>
888 +#include <uuid/uuid.h>
889 +
890 +#include "qemu-common.h"
891 +#include "vma.h"
892 +#include "block/block.h"
893 +#include "monitor/monitor.h"
894 +#include "qemu/main-loop.h"
895 +
896 +#define DEBUG_VMA 0
897 +
898 +#define DPRINTF(fmt, ...)\
899 + do { if (DEBUG_VMA) { printf("vma: " fmt, ## __VA_ARGS__); } } while (0)
900 +
901 +#define WRITE_BUFFERS 5
902 +
903 +typedef struct VmaAIOCB VmaAIOCB;
904 +struct VmaAIOCB {
905 + unsigned char buffer[VMA_MAX_EXTENT_SIZE];
906 + VmaWriter *vmaw;
907 + size_t bytes;
908 + Coroutine *co;
909 +};
910 +
911 +struct VmaWriter {
912 + int fd;
913 + FILE *cmd;
914 + int status;
915 + char errmsg[8192];
916 + uuid_t uuid;
917 + bool header_written;
918 + bool closed;
919 +
920 + /* we always write extents */
921 + unsigned char outbuf[VMA_MAX_EXTENT_SIZE];
922 + int outbuf_pos; /* in bytes */
923 + int outbuf_count; /* in VMA_BLOCKS */
924 + uint64_t outbuf_block_info[VMA_BLOCKS_PER_EXTENT];
925 +
926 + VmaAIOCB *aiocbs[WRITE_BUFFERS];
927 + CoQueue wqueue;
928 +
929 + GChecksum *md5csum;
930 + CoMutex writer_lock;
931 + CoMutex flush_lock;
932 + Coroutine *co_writer;
933 +
934 + /* drive informations */
935 + VmaStreamInfo stream_info[256];
936 + guint stream_count;
937 +
938 + guint8 vmstate_stream;
939 + uint32_t vmstate_clusters;
940 +
941 + /* header blob table */
942 + char *header_blob_table;
943 + uint32_t header_blob_table_size;
944 + uint32_t header_blob_table_pos;
945 +
946 + /* store for config blobs */
947 + uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
948 + uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
949 + uint32_t config_count;
950 +};
951 +
952 +void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...)
953 +{
954 + va_list ap;
955 +
956 + if (vmaw->status < 0) {
957 + return;
958 + }
959 +
960 + vmaw->status = -1;
961 +
962 + va_start(ap, fmt);
963 + g_vsnprintf(vmaw->errmsg, sizeof(vmaw->errmsg), fmt, ap);
964 + va_end(ap);
965 +
966 + DPRINTF("vma_writer_set_error: %s\n", vmaw->errmsg);
967 +}
968 +
969 +static uint32_t allocate_header_blob(VmaWriter *vmaw, const char *data,
970 + size_t len)
971 +{
972 + if (len > 65535) {
973 + return 0;
974 + }
975 +
976 + if (!vmaw->header_blob_table ||
977 + (vmaw->header_blob_table_size <
978 + (vmaw->header_blob_table_pos + len + 2))) {
979 + int newsize = vmaw->header_blob_table_size + ((len + 2 + 511)/512)*512;
980 +
981 + vmaw->header_blob_table = g_realloc(vmaw->header_blob_table, newsize);
982 + memset(vmaw->header_blob_table + vmaw->header_blob_table_size,
983 + 0, newsize - vmaw->header_blob_table_size);
984 + vmaw->header_blob_table_size = newsize;
985 + }
986 +
987 + uint32_t cpos = vmaw->header_blob_table_pos;
988 + vmaw->header_blob_table[cpos] = len & 255;
989 + vmaw->header_blob_table[cpos+1] = (len >> 8) & 255;
990 + memcpy(vmaw->header_blob_table + cpos + 2, data, len);
991 + vmaw->header_blob_table_pos += len + 2;
992 + return cpos;
993 +}
994 +
995 +static uint32_t allocate_header_string(VmaWriter *vmaw, const char *str)
996 +{
997 + assert(vmaw);
998 +
999 + size_t len = strlen(str) + 1;
1000 +
1001 + return allocate_header_blob(vmaw, str, len);
1002 +}
1003 +
1004 +int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
1005 + gsize len)
1006 +{
1007 + assert(vmaw);
1008 + assert(!vmaw->header_written);
1009 + assert(vmaw->config_count < VMA_MAX_CONFIGS);
1010 + assert(name);
1011 + assert(data);
1012 + assert(len);
1013 +
1014 + gchar *basename = g_path_get_basename(name);
1015 + uint32_t name_ptr = allocate_header_string(vmaw, basename);
1016 + g_free(basename);
1017 +
1018 + if (!name_ptr) {
1019 + return -1;
1020 + }
1021 +
1022 + uint32_t data_ptr = allocate_header_blob(vmaw, data, len);
1023 + if (!data_ptr) {
1024 + return -1;
1025 + }
1026 +
1027 + vmaw->config_names[vmaw->config_count] = name_ptr;
1028 + vmaw->config_data[vmaw->config_count] = data_ptr;
1029 +
1030 + vmaw->config_count++;
1031 +
1032 + return 0;
1033 +}
1034 +
1035 +int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
1036 + size_t size)
1037 +{
1038 + assert(vmaw);
1039 + assert(devname);
1040 + assert(!vmaw->status);
1041 +
1042 + if (vmaw->header_written) {
1043 + vma_writer_set_error(vmaw, "vma_writer_register_stream: header "
1044 + "already written");
1045 + return -1;
1046 + }
1047 +
1048 + guint n = vmaw->stream_count + 1;
1049 +
1050 + /* we can have dev_ids form 1 to 255 (0 reserved)
1051 + * 255(-1) reseverd for safety
1052 + */
1053 + if (n > 254) {
1054 + vma_writer_set_error(vmaw, "vma_writer_register_stream: "
1055 + "too many drives");
1056 + return -1;
1057 + }
1058 +
1059 + if (size <= 0) {
1060 + vma_writer_set_error(vmaw, "vma_writer_register_stream: "
1061 + "got strange size %zd", size);
1062 + return -1;
1063 + }
1064 +
1065 + DPRINTF("vma_writer_register_stream %s %zu %d\n", devname, size, n);
1066 +
1067 + vmaw->stream_info[n].devname = g_strdup(devname);
1068 + vmaw->stream_info[n].size = size;
1069 +
1070 + vmaw->stream_info[n].cluster_count = (size + VMA_CLUSTER_SIZE - 1) /
1071 + VMA_CLUSTER_SIZE;
1072 +
1073 + vmaw->stream_count = n;
1074 +
1075 + if (strcmp(devname, "vmstate") == 0) {
1076 + vmaw->vmstate_stream = n;
1077 + }
1078 +
1079 + return n;
1080 +}
1081 +
1082 +static void vma_co_continue_write(void *opaque)
1083 +{
1084 + VmaWriter *vmaw = opaque;
1085 +
1086 + DPRINTF("vma_co_continue_write\n");
1087 + qemu_coroutine_enter(vmaw->co_writer, NULL);
1088 +}
1089 +
1090 +static ssize_t coroutine_fn
1091 +vma_co_write(VmaWriter *vmaw, const void *buf, size_t bytes)
1092 +{
1093 + size_t done = 0;
1094 + ssize_t ret;
1095 +
1096 + /* atomic writes (we cannot interleave writes) */
1097 + qemu_co_mutex_lock(&vmaw->writer_lock);
1098 +
1099 + DPRINTF("vma_co_write enter %zd\n", bytes);
1100 +
1101 + assert(vmaw->co_writer == NULL);
1102 +
1103 + vmaw->co_writer = qemu_coroutine_self();
1104 +
1105 + aio_set_fd_handler(qemu_get_aio_context(), vmaw->fd, NULL, vma_co_continue_write, vmaw);
1106 +
1107 + DPRINTF("vma_co_write wait until writable\n");
1108 + qemu_coroutine_yield();
1109 + DPRINTF("vma_co_write starting %zd\n", bytes);
1110 +
1111 + while (done < bytes) {
1112 + ret = write(vmaw->fd, buf + done, bytes - done);
1113 + if (ret > 0) {
1114 + done += ret;
1115 + DPRINTF("vma_co_write written %zd %zd\n", done, ret);
1116 + } else if (ret < 0) {
1117 + if (errno == EAGAIN || errno == EWOULDBLOCK) {
1118 + DPRINTF("vma_co_write yield %zd\n", done);
1119 + qemu_coroutine_yield();
1120 + DPRINTF("vma_co_write restart %zd\n", done);
1121 + } else {
1122 + vma_writer_set_error(vmaw, "vma_co_write write error - %s",
1123 + g_strerror(errno));
1124 + done = -1; /* always return failure for partial writes */
1125 + break;
1126 + }
1127 + } else if (ret == 0) {
1128 + /* should not happen - simply try again */
1129 + }
1130 + }
1131 +
1132 + aio_set_fd_handler(qemu_get_aio_context(), vmaw->fd, NULL, NULL, NULL);
1133 +
1134 + vmaw->co_writer = NULL;
1135 +
1136 + qemu_co_mutex_unlock(&vmaw->writer_lock);
1137 +
1138 + DPRINTF("vma_co_write leave %zd\n", done);
1139 + return done;
1140 +}
1141 +
1142 +static void coroutine_fn vma_co_writer_task(void *opaque)
1143 +{
1144 + VmaAIOCB *cb = opaque;
1145 +
1146 + DPRINTF("vma_co_writer_task start\n");
1147 +
1148 + int64_t done = vma_co_write(cb->vmaw, cb->buffer, cb->bytes);
1149 + DPRINTF("vma_co_writer_task write done %zd\n", done);
1150 +
1151 + if (done != cb->bytes) {
1152 + DPRINTF("vma_co_writer_task failed write %zd %zd", cb->bytes, done);
1153 + vma_writer_set_error(cb->vmaw, "vma_co_writer_task failed write %zd",
1154 + done);
1155 + }
1156 +
1157 + cb->bytes = 0;
1158 +
1159 + qemu_co_queue_next(&cb->vmaw->wqueue);
1160 +
1161 + DPRINTF("vma_co_writer_task end\n");
1162 +}
1163 +
1164 +static void coroutine_fn vma_queue_flush(VmaWriter *vmaw)
1165 +{
1166 + DPRINTF("vma_queue_flush enter\n");
1167 +
1168 + assert(vmaw);
1169 +
1170 + while (1) {
1171 + int i;
1172 + VmaAIOCB *cb = NULL;
1173 + for (i = 0; i < WRITE_BUFFERS; i++) {
1174 + if (vmaw->aiocbs[i]->bytes) {
1175 + cb = vmaw->aiocbs[i];
1176 + DPRINTF("FOUND USED AIO BUFFER %d %zd\n", i,
1177 + vmaw->aiocbs[i]->bytes);
1178 + break;
1179 + }
1180 + }
1181 + if (!cb) {
1182 + break;
1183 + }
1184 + qemu_co_queue_wait(&vmaw->wqueue);
1185 + }
1186 +
1187 + DPRINTF("vma_queue_flush leave\n");
1188 +}
1189 +
1190 +/**
1191 + * NOTE: pipe buffer size in only 4096 bytes on linux (see 'ulimit -a')
1192 + * So we need to create a coroutione to allow 'parallel' execution.
1193 + */
1194 +static ssize_t coroutine_fn
1195 +vma_queue_write(VmaWriter *vmaw, const void *buf, size_t bytes)
1196 +{
1197 + DPRINTF("vma_queue_write enter %zd\n", bytes);
1198 +
1199 + assert(vmaw);
1200 + assert(buf);
1201 + assert(bytes <= VMA_MAX_EXTENT_SIZE);
1202 +
1203 + VmaAIOCB *cb = NULL;
1204 + while (!cb) {
1205 + int i;
1206 + for (i = 0; i < WRITE_BUFFERS; i++) {
1207 + if (!vmaw->aiocbs[i]->bytes) {
1208 + cb = vmaw->aiocbs[i];
1209 + break;
1210 + }
1211 + }
1212 + if (!cb) {
1213 + qemu_co_queue_wait(&vmaw->wqueue);
1214 + }
1215 + }
1216 +
1217 + memcpy(cb->buffer, buf, bytes);
1218 + cb->bytes = bytes;
1219 + cb->vmaw = vmaw;
1220 +
1221 + DPRINTF("vma_queue_write start %zd\n", bytes);
1222 + cb->co = qemu_coroutine_create(vma_co_writer_task);
1223 + qemu_coroutine_enter(cb->co, cb);
1224 +
1225 + DPRINTF("vma_queue_write leave\n");
1226 +
1227 + return bytes;
1228 +}
1229 +
1230 +VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp)
1231 +{
1232 + const char *p;
1233 +
1234 + assert(sizeof(VmaHeader) == (4096 + 8192));
1235 + assert(G_STRUCT_OFFSET(VmaHeader, config_names) == 2044);
1236 + assert(G_STRUCT_OFFSET(VmaHeader, config_data) == 3068);
1237 + assert(G_STRUCT_OFFSET(VmaHeader, dev_info) == 4096);
1238 + assert(sizeof(VmaExtentHeader) == 512);
1239 +
1240 + VmaWriter *vmaw = g_new0(VmaWriter, 1);
1241 + vmaw->fd = -1;
1242 +
1243 + vmaw->md5csum = g_checksum_new(G_CHECKSUM_MD5);
1244 + if (!vmaw->md5csum) {
1245 + error_setg(errp, "can't allocate cmsum\n");
1246 + goto err;
1247 + }
1248 +
1249 + if (strstart(filename, "exec:", &p)) {
1250 + vmaw->cmd = popen(p, "w");
1251 + if (vmaw->cmd == NULL) {
1252 + error_setg(errp, "can't popen command '%s' - %s\n", p,
1253 + g_strerror(errno));
1254 + goto err;
1255 + }
1256 + vmaw->fd = fileno(vmaw->cmd);
1257 +
1258 + /* try to use O_NONBLOCK and O_DIRECT */
1259 + fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
1260 + fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_DIRECT);
1261 +
1262 + } else {
1263 + struct stat st;
1264 + int oflags;
1265 + const char *tmp_id_str;
1266 +
1267 + if ((stat(filename, &st) == 0) && S_ISFIFO(st.st_mode)) {
1268 + oflags = O_NONBLOCK|O_DIRECT|O_WRONLY;
1269 + vmaw->fd = qemu_open(filename, oflags, 0644);
1270 + } else if (strstart(filename, "/dev/fdset/", &tmp_id_str)) {
1271 + oflags = O_NONBLOCK|O_DIRECT|O_WRONLY;
1272 + vmaw->fd = qemu_open(filename, oflags, 0644);
1273 + } else if (strstart(filename, "/dev/fdname/", &tmp_id_str)) {
1274 + vmaw->fd = monitor_get_fd(cur_mon, tmp_id_str, errp);
1275 + if (vmaw->fd < 0) {
1276 + goto err;
1277 + }
1278 + /* try to use O_NONBLOCK and O_DIRECT */
1279 + fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_NONBLOCK);
1280 + fcntl(vmaw->fd, F_SETFL, fcntl(vmaw->fd, F_GETFL)|O_DIRECT);
1281 + } else {
1282 + oflags = O_NONBLOCK|O_DIRECT|O_WRONLY|O_CREAT|O_EXCL;
1283 + vmaw->fd = qemu_open(filename, oflags, 0644);
1284 + }
1285 +
1286 + if (vmaw->fd < 0) {
1287 + error_setg(errp, "can't open file %s - %s\n", filename,
1288 + g_strerror(errno));
1289 + goto err;
1290 + }
1291 + }
1292 +
1293 + /* we use O_DIRECT, so we need to align IO buffers */
1294 + int i;
1295 + for (i = 0; i < WRITE_BUFFERS; i++) {
1296 + vmaw->aiocbs[i] = qemu_memalign(512, sizeof(VmaAIOCB));
1297 + memset(vmaw->aiocbs[i], 0, sizeof(VmaAIOCB));
1298 + }
1299 +
1300 + vmaw->outbuf_count = 0;
1301 + vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
1302 +
1303 + vmaw->header_blob_table_pos = 1; /* start at pos 1 */
1304 +
1305 + qemu_co_mutex_init(&vmaw->writer_lock);
1306 + qemu_co_mutex_init(&vmaw->flush_lock);
1307 + qemu_co_queue_init(&vmaw->wqueue);
1308 +
1309 + uuid_copy(vmaw->uuid, uuid);
1310 +
1311 + return vmaw;
1312 +
1313 +err:
1314 + if (vmaw) {
1315 + if (vmaw->cmd) {
1316 + pclose(vmaw->cmd);
1317 + } else if (vmaw->fd >= 0) {
1318 + close(vmaw->fd);
1319 + }
1320 +
1321 + if (vmaw->md5csum) {
1322 + g_checksum_free(vmaw->md5csum);
1323 + }
1324 +
1325 + g_free(vmaw);
1326 + }
1327 +
1328 + return NULL;
1329 +}
1330 +
1331 +static int coroutine_fn vma_write_header(VmaWriter *vmaw)
1332 +{
1333 + assert(vmaw);
1334 + int header_clusters = 8;
1335 + char buf[65536*header_clusters];
1336 + VmaHeader *head = (VmaHeader *)buf;
1337 +
1338 + int i;
1339 +
1340 + DPRINTF("VMA WRITE HEADER\n");
1341 +
1342 + if (vmaw->status < 0) {
1343 + return vmaw->status;
1344 + }
1345 +
1346 + memset(buf, 0, sizeof(buf));
1347 +
1348 + head->magic = VMA_MAGIC;
1349 + head->version = GUINT32_TO_BE(1); /* v1 */
1350 + memcpy(head->uuid, vmaw->uuid, 16);
1351 +
1352 + time_t ctime = time(NULL);
1353 + head->ctime = GUINT64_TO_BE(ctime);
1354 +
1355 + if (!vmaw->stream_count) {
1356 + return -1;
1357 + }
1358 +
1359 + for (i = 0; i < VMA_MAX_CONFIGS; i++) {
1360 + head->config_names[i] = GUINT32_TO_BE(vmaw->config_names[i]);
1361 + head->config_data[i] = GUINT32_TO_BE(vmaw->config_data[i]);
1362 + }
1363 +
1364 + /* 32 bytes per device (12 used currently) = 8192 bytes max */
1365 + for (i = 1; i <= 254; i++) {
1366 + VmaStreamInfo *si = &vmaw->stream_info[i];
1367 + if (si->size) {
1368 + assert(si->devname);
1369 + uint32_t devname_ptr = allocate_header_string(vmaw, si->devname);
1370 + if (!devname_ptr) {
1371 + return -1;
1372 + }
1373 + head->dev_info[i].devname_ptr = GUINT32_TO_BE(devname_ptr);
1374 + head->dev_info[i].size = GUINT64_TO_BE(si->size);
1375 + }
1376 + }
1377 +
1378 + uint32_t header_size = sizeof(VmaHeader) + vmaw->header_blob_table_size;
1379 + head->header_size = GUINT32_TO_BE(header_size);
1380 +
1381 + if (header_size > sizeof(buf)) {
1382 + return -1; /* just to be sure */
1383 + }
1384 +
1385 + uint32_t blob_buffer_offset = sizeof(VmaHeader);
1386 + memcpy(buf + blob_buffer_offset, vmaw->header_blob_table,
1387 + vmaw->header_blob_table_size);
1388 + head->blob_buffer_offset = GUINT32_TO_BE(blob_buffer_offset);
1389 + head->blob_buffer_size = GUINT32_TO_BE(vmaw->header_blob_table_pos);
1390 +
1391 + g_checksum_reset(vmaw->md5csum);
1392 + g_checksum_update(vmaw->md5csum, (const guchar *)buf, header_size);
1393 + gsize csize = 16;
1394 + g_checksum_get_digest(vmaw->md5csum, (guint8 *)(head->md5sum), &csize);
1395 +
1396 + return vma_queue_write(vmaw, buf, header_size);
1397 +}
1398 +
1399 +static int coroutine_fn vma_writer_flush(VmaWriter *vmaw)
1400 +{
1401 + assert(vmaw);
1402 +
1403 + int ret;
1404 + int i;
1405 +
1406 + if (vmaw->status < 0) {
1407 + return vmaw->status;
1408 + }
1409 +
1410 + if (!vmaw->header_written) {
1411 + vmaw->header_written = true;
1412 + ret = vma_write_header(vmaw);
1413 + if (ret < 0) {
1414 + vma_writer_set_error(vmaw, "vma_writer_flush: write header failed");
1415 + return ret;
1416 + }
1417 + }
1418 +
1419 + DPRINTF("VMA WRITE FLUSH %d %d\n", vmaw->outbuf_count, vmaw->outbuf_pos);
1420 +
1421 +
1422 + VmaExtentHeader *ehead = (VmaExtentHeader *)vmaw->outbuf;
1423 +
1424 + ehead->magic = VMA_EXTENT_MAGIC;
1425 + ehead->reserved1 = 0;
1426 +
1427 + for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
1428 + ehead->blockinfo[i] = GUINT64_TO_BE(vmaw->outbuf_block_info[i]);
1429 + }
1430 +
1431 + guint16 block_count = (vmaw->outbuf_pos - VMA_EXTENT_HEADER_SIZE) /
1432 + VMA_BLOCK_SIZE;
1433 +
1434 + ehead->block_count = GUINT16_TO_BE(block_count);
1435 +
1436 + memcpy(ehead->uuid, vmaw->uuid, sizeof(ehead->uuid));
1437 + memset(ehead->md5sum, 0, sizeof(ehead->md5sum));
1438 +
1439 + g_checksum_reset(vmaw->md5csum);
1440 + g_checksum_update(vmaw->md5csum, vmaw->outbuf, VMA_EXTENT_HEADER_SIZE);
1441 + gsize csize = 16;
1442 + g_checksum_get_digest(vmaw->md5csum, ehead->md5sum, &csize);
1443 +
1444 + int bytes = vmaw->outbuf_pos;
1445 + ret = vma_queue_write(vmaw, vmaw->outbuf, bytes);
1446 + if (ret != bytes) {
1447 + vma_writer_set_error(vmaw, "vma_writer_flush: failed write");
1448 + }
1449 +
1450 + vmaw->outbuf_count = 0;
1451 + vmaw->outbuf_pos = VMA_EXTENT_HEADER_SIZE;
1452 +
1453 + for (i = 0; i < VMA_BLOCKS_PER_EXTENT; i++) {
1454 + vmaw->outbuf_block_info[i] = 0;
1455 + }
1456 +
1457 + return vmaw->status;
1458 +}
1459 +
1460 +static int vma_count_open_streams(VmaWriter *vmaw)
1461 +{
1462 + g_assert(vmaw != NULL);
1463 +
1464 + int i;
1465 + int open_drives = 0;
1466 + for (i = 0; i <= 255; i++) {
1467 + if (vmaw->stream_info[i].size && !vmaw->stream_info[i].finished) {
1468 + open_drives++;
1469 + }
1470 + }
1471 +
1472 + return open_drives;
1473 +}
1474 +
1475 +/**
1476 + * all jobs should call this when there is no more data
1477 + * Returns: number of remaining stream (0 ==> finished)
1478 + */
1479 +int coroutine_fn
1480 +vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id)
1481 +{
1482 + g_assert(vmaw != NULL);
1483 +
1484 + DPRINTF("vma_writer_set_status %d\n", dev_id);
1485 + if (!vmaw->stream_info[dev_id].size) {
1486 + vma_writer_set_error(vmaw, "vma_writer_close_stream: "
1487 + "no such stream %d", dev_id);
1488 + return -1;
1489 + }
1490 + if (vmaw->stream_info[dev_id].finished) {
1491 + vma_writer_set_error(vmaw, "vma_writer_close_stream: "
1492 + "stream already closed %d", dev_id);
1493 + return -1;
1494 + }
1495 +
1496 + vmaw->stream_info[dev_id].finished = true;
1497 +
1498 + int open_drives = vma_count_open_streams(vmaw);
1499 +
1500 + if (open_drives <= 0) {
1501 + DPRINTF("vma_writer_set_status all drives completed\n");
1502 + qemu_co_mutex_lock(&vmaw->flush_lock);
1503 + int ret = vma_writer_flush(vmaw);
1504 + qemu_co_mutex_unlock(&vmaw->flush_lock);
1505 + if (ret < 0) {
1506 + vma_writer_set_error(vmaw, "vma_writer_close_stream: flush failed");
1507 + }
1508 + }
1509 +
1510 + return open_drives;
1511 +}
1512 +
1513 +int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status)
1514 +{
1515 + int i;
1516 +
1517 + g_assert(vmaw != NULL);
1518 +
1519 + if (status) {
1520 + status->status = vmaw->status;
1521 + g_strlcpy(status->errmsg, vmaw->errmsg, sizeof(status->errmsg));
1522 + for (i = 0; i <= 255; i++) {
1523 + status->stream_info[i] = vmaw->stream_info[i];
1524 + }
1525 +
1526 + uuid_unparse_lower(vmaw->uuid, status->uuid_str);
1527 + }
1528 +
1529 + status->closed = vmaw->closed;
1530 +
1531 + return vmaw->status;
1532 +}
1533 +
1534 +static int vma_writer_get_buffer(VmaWriter *vmaw)
1535 +{
1536 + int ret = 0;
1537 +
1538 + qemu_co_mutex_lock(&vmaw->flush_lock);
1539 +
1540 + /* wait until buffer is available */
1541 + while (vmaw->outbuf_count >= (VMA_BLOCKS_PER_EXTENT - 1)) {
1542 + ret = vma_writer_flush(vmaw);
1543 + if (ret < 0) {
1544 + vma_writer_set_error(vmaw, "vma_writer_get_buffer: flush failed");
1545 + break;
1546 + }
1547 + }
1548 +
1549 + qemu_co_mutex_unlock(&vmaw->flush_lock);
1550 +
1551 + return ret;
1552 +}
1553 +
1554 +
1555 +int64_t coroutine_fn
1556 +vma_writer_write(VmaWriter *vmaw, uint8_t dev_id, int64_t cluster_num,
1557 + unsigned char *buf, size_t *zero_bytes)
1558 +{
1559 + g_assert(vmaw != NULL);
1560 + g_assert(zero_bytes != NULL);
1561 +
1562 + *zero_bytes = 0;
1563 +
1564 + if (vmaw->status < 0) {
1565 + return vmaw->status;
1566 + }
1567 +
1568 + if (!dev_id || !vmaw->stream_info[dev_id].size) {
1569 + vma_writer_set_error(vmaw, "vma_writer_write: "
1570 + "no such stream %d", dev_id);
1571 + return -1;
1572 + }
1573 +
1574 + if (vmaw->stream_info[dev_id].finished) {
1575 + vma_writer_set_error(vmaw, "vma_writer_write: "
1576 + "stream already closed %d", dev_id);
1577 + return -1;
1578 + }
1579 +
1580 +
1581 + if (cluster_num >= (((uint64_t)1)<<32)) {
1582 + vma_writer_set_error(vmaw, "vma_writer_write: "
1583 + "cluster number out of range");
1584 + return -1;
1585 + }
1586 +
1587 + if (dev_id == vmaw->vmstate_stream) {
1588 + if (cluster_num != vmaw->vmstate_clusters) {
1589 + vma_writer_set_error(vmaw, "vma_writer_write: "
1590 + "non sequential vmstate write");
1591 + }
1592 + vmaw->vmstate_clusters++;
1593 + } else if (cluster_num >= vmaw->stream_info[dev_id].cluster_count) {
1594 + vma_writer_set_error(vmaw, "vma_writer_write: cluster number too big");
1595 + return -1;
1596 + }
1597 +
1598 + /* wait until buffer is available */
1599 + if (vma_writer_get_buffer(vmaw) < 0) {
1600 + vma_writer_set_error(vmaw, "vma_writer_write: "
1601 + "vma_writer_get_buffer failed");
1602 + return -1;
1603 + }
1604 +
1605 + DPRINTF("VMA WRITE %d %zd\n", dev_id, cluster_num);
1606 +
1607 + uint16_t mask = 0;
1608 +
1609 + if (buf) {
1610 + int i;
1611 + int bit = 1;
1612 + for (i = 0; i < 16; i++) {
1613 + unsigned char *vmablock = buf + (i*VMA_BLOCK_SIZE);
1614 + if (!buffer_is_zero(vmablock, VMA_BLOCK_SIZE)) {
1615 + mask |= bit;
1616 + memcpy(vmaw->outbuf + vmaw->outbuf_pos, vmablock,
1617 + VMA_BLOCK_SIZE);
1618 + vmaw->outbuf_pos += VMA_BLOCK_SIZE;
1619 + } else {
1620 + DPRINTF("VMA WRITE %zd ZERO BLOCK %d\n", cluster_num, i);
1621 + vmaw->stream_info[dev_id].zero_bytes += VMA_BLOCK_SIZE;
1622 + *zero_bytes += VMA_BLOCK_SIZE;
1623 + }
1624 +
1625 + bit = bit << 1;
1626 + }
1627 + } else {
1628 + DPRINTF("VMA WRITE %zd ZERO CLUSTER\n", cluster_num);
1629 + vmaw->stream_info[dev_id].zero_bytes += VMA_CLUSTER_SIZE;
1630 + *zero_bytes += VMA_CLUSTER_SIZE;
1631 + }
1632 +
1633 + uint64_t block_info = ((uint64_t)mask) << (32+16);
1634 + block_info |= ((uint64_t)dev_id) << 32;
1635 + block_info |= (cluster_num & 0xffffffff);
1636 + vmaw->outbuf_block_info[vmaw->outbuf_count] = block_info;
1637 +
1638 + DPRINTF("VMA WRITE MASK %zd %zx\n", cluster_num, block_info);
1639 +
1640 + vmaw->outbuf_count++;
1641 +
1642 + /** NOTE: We allways write whole clusters, but we correctly set
1643 + * transferred bytes. So transferred == size when when everything
1644 + * went OK.
1645 + */
1646 + size_t transferred = VMA_CLUSTER_SIZE;
1647 +
1648 + if (dev_id != vmaw->vmstate_stream) {
1649 + uint64_t last = (cluster_num + 1) * VMA_CLUSTER_SIZE;
1650 + if (last > vmaw->stream_info[dev_id].size) {
1651 + uint64_t diff = last - vmaw->stream_info[dev_id].size;
1652 + if (diff >= VMA_CLUSTER_SIZE) {
1653 + vma_writer_set_error(vmaw, "vma_writer_write: "
1654 + "read after last cluster");
1655 + return -1;
1656 + }
1657 + transferred -= diff;
1658 + }
1659 + }
1660 +
1661 + vmaw->stream_info[dev_id].transferred += transferred;
1662 +
1663 + return transferred;
1664 +}
1665 +
1666 +int vma_writer_close(VmaWriter *vmaw, Error **errp)
1667 +{
1668 + g_assert(vmaw != NULL);
1669 +
1670 + int i;
1671 +
1672 + vma_queue_flush(vmaw);
1673 +
1674 + /* this should not happen - just to be sure */
1675 + while (!qemu_co_queue_empty(&vmaw->wqueue)) {
1676 + DPRINTF("vma_writer_close wait\n");
1677 + co_aio_sleep_ns(qemu_get_aio_context(), QEMU_CLOCK_REALTIME, 1000000);
1678 + }
1679 +
1680 + if (vmaw->cmd) {
1681 + if (pclose(vmaw->cmd) < 0) {
1682 + vma_writer_set_error(vmaw, "vma_writer_close: "
1683 + "pclose failed - %s", g_strerror(errno));
1684 + }
1685 + } else {
1686 + if (close(vmaw->fd) < 0) {
1687 + vma_writer_set_error(vmaw, "vma_writer_close: "
1688 + "close failed - %s", g_strerror(errno));
1689 + }
1690 + }
1691 +
1692 + for (i = 0; i <= 255; i++) {
1693 + VmaStreamInfo *si = &vmaw->stream_info[i];
1694 + if (si->size) {
1695 + if (!si->finished) {
1696 + vma_writer_set_error(vmaw, "vma_writer_close: "
1697 + "detected open stream '%s'", si->devname);
1698 + } else if ((si->transferred != si->size) &&
1699 + (i != vmaw->vmstate_stream)) {
1700 + vma_writer_set_error(vmaw, "vma_writer_close: "
1701 + "incomplete stream '%s' (%zd != %zd)",
1702 + si->devname, si->transferred, si->size);
1703 + }
1704 + }
1705 + }
1706 +
1707 + for (i = 0; i <= 255; i++) {
1708 + vmaw->stream_info[i].finished = 1; /* mark as closed */
1709 + }
1710 +
1711 + vmaw->closed = 1;
1712 +
1713 + if (vmaw->status < 0 && *errp == NULL) {
1714 + error_setg(errp, "%s", vmaw->errmsg);
1715 + }
1716 +
1717 + return vmaw->status;
1718 +}
1719 +
1720 +void vma_writer_destroy(VmaWriter *vmaw)
1721 +{
1722 + assert(vmaw);
1723 +
1724 + int i;
1725 +
1726 + for (i = 0; i <= 255; i++) {
1727 + if (vmaw->stream_info[i].devname) {
1728 + g_free(vmaw->stream_info[i].devname);
1729 + }
1730 + }
1731 +
1732 + if (vmaw->md5csum) {
1733 + g_checksum_free(vmaw->md5csum);
1734 + }
1735 +
1736 + for (i = 0; i < WRITE_BUFFERS; i++) {
1737 + free(vmaw->aiocbs[i]);
1738 + }
1739 +
1740 + g_free(vmaw);
1741 +}
1742 diff --git a/vma.c b/vma.c
1743 new file mode 100644
1744 index 0000000..86c117b
1745 --- /dev/null
1746 +++ b/vma.c
1747 @@ -0,0 +1,582 @@
1748 +/*
1749 + * VMA: Virtual Machine Archive
1750 + *
1751 + * Copyright (C) 2012-2013 Proxmox Server Solutions
1752 + *
1753 + * Authors:
1754 + * Dietmar Maurer (dietmar@proxmox.com)
1755 + *
1756 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
1757 + * See the COPYING file in the top-level directory.
1758 + *
1759 + */
1760 +
1761 +#include <stdio.h>
1762 +#include <errno.h>
1763 +#include <unistd.h>
1764 +#include <stdio.h>
1765 +#include <string.h>
1766 +#include <sys/types.h>
1767 +#include <sys/stat.h>
1768 +#include <fcntl.h>
1769 +#include <glib.h>
1770 +
1771 +#include "vma.h"
1772 +#include "qemu-common.h"
1773 +#include "qemu/error-report.h"
1774 +#include "qemu/main-loop.h"
1775 +
1776 +static void help(void)
1777 +{
1778 + const char *help_msg =
1779 + "usage: vma command [command options]\n"
1780 + "\n"
1781 + "vma list <filename>\n"
1782 + "vma create <filename> [-c config] <archive> pathname ...\n"
1783 + "vma extract <filename> [-r <fifo>] <targetdir>\n"
1784 + ;
1785 +
1786 + printf("%s", help_msg);
1787 + exit(1);
1788 +}
1789 +
1790 +static const char *extract_devname(const char *path, char **devname, int index)
1791 +{
1792 + assert(path);
1793 +
1794 + const char *sep = strchr(path, '=');
1795 +
1796 + if (sep) {
1797 + *devname = g_strndup(path, sep - path);
1798 + path = sep + 1;
1799 + } else {
1800 + if (index >= 0) {
1801 + *devname = g_strdup_printf("disk%d", index);
1802 + } else {
1803 + *devname = NULL;
1804 + }
1805 + }
1806 +
1807 + return path;
1808 +}
1809 +
1810 +static void print_content(VmaReader *vmar)
1811 +{
1812 + assert(vmar);
1813 +
1814 + VmaHeader *head = vma_reader_get_header(vmar);
1815 +
1816 + GList *l = vma_reader_get_config_data(vmar);
1817 + while (l && l->data) {
1818 + VmaConfigData *cdata = (VmaConfigData *)l->data;
1819 + l = g_list_next(l);
1820 + printf("CFG: size: %d name: %s\n", cdata->len, cdata->name);
1821 + }
1822 +
1823 + int i;
1824 + VmaDeviceInfo *di;
1825 + for (i = 1; i < 255; i++) {
1826 + di = vma_reader_get_device_info(vmar, i);
1827 + if (di) {
1828 + if (strcmp(di->devname, "vmstate") == 0) {
1829 + printf("VMSTATE: dev_id=%d memory: %zd\n", i, di->size);
1830 + } else {
1831 + printf("DEV: dev_id=%d size: %zd devname: %s\n",
1832 + i, di->size, di->devname);
1833 + }
1834 + }
1835 + }
1836 + /* ctime is the last entry we print */
1837 + printf("CTIME: %s", ctime(&head->ctime));
1838 + fflush(stdout);
1839 +}
1840 +
1841 +static int list_content(int argc, char **argv)
1842 +{
1843 + int c, ret = 0;
1844 + const char *filename;
1845 +
1846 + for (;;) {
1847 + c = getopt(argc, argv, "h");
1848 + if (c == -1) {
1849 + break;
1850 + }
1851 + switch (c) {
1852 + case '?':
1853 + case 'h':
1854 + help();
1855 + break;
1856 + default:
1857 + g_assert_not_reached();
1858 + }
1859 + }
1860 +
1861 + /* Get the filename */
1862 + if ((optind + 1) != argc) {
1863 + help();
1864 + }
1865 + filename = argv[optind++];
1866 +
1867 + Error *errp = NULL;
1868 + VmaReader *vmar = vma_reader_create(filename, &errp);
1869 +
1870 + if (!vmar) {
1871 + g_error("%s", error_get_pretty(errp));
1872 + }
1873 +
1874 + print_content(vmar);
1875 +
1876 + vma_reader_destroy(vmar);
1877 +
1878 + return ret;
1879 +}
1880 +
1881 +typedef struct RestoreMap {
1882 + char *devname;
1883 + char *path;
1884 + bool write_zero;
1885 +} RestoreMap;
1886 +
1887 +static int extract_content(int argc, char **argv)
1888 +{
1889 + int c, ret = 0;
1890 + int verbose = 0;
1891 + const char *filename;
1892 + const char *dirname;
1893 + const char *readmap = NULL;
1894 +
1895 + for (;;) {
1896 + c = getopt(argc, argv, "hvr:");
1897 + if (c == -1) {
1898 + break;
1899 + }
1900 + switch (c) {
1901 + case '?':
1902 + case 'h':
1903 + help();
1904 + break;
1905 + case 'r':
1906 + readmap = optarg;
1907 + break;
1908 + case 'v':
1909 + verbose = 1;
1910 + break;
1911 + default:
1912 + help();
1913 + }
1914 + }
1915 +
1916 + /* Get the filename */
1917 + if ((optind + 2) != argc) {
1918 + help();
1919 + }
1920 + filename = argv[optind++];
1921 + dirname = argv[optind++];
1922 +
1923 + Error *errp = NULL;
1924 + VmaReader *vmar = vma_reader_create(filename, &errp);
1925 +
1926 + if (!vmar) {
1927 + g_error("%s", error_get_pretty(errp));
1928 + }
1929 +
1930 + if (mkdir(dirname, 0777) < 0) {
1931 + g_error("unable to create target directory %s - %s",
1932 + dirname, g_strerror(errno));
1933 + }
1934 +
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,
1942 + &err)) {
1943 + g_error("unable to write file: %s", err->message);
1944 + }
1945 + }
1946 +
1947 + GHashTable *devmap = g_hash_table_new(g_str_hash, g_str_equal);
1948 +
1949 + if (readmap) {
1950 + print_content(vmar);
1951 +
1952 + FILE *map = fopen(readmap, "r");
1953 + if (!map) {
1954 + g_error("unable to open fifo %s - %s", readmap, g_strerror(errno));
1955 + }
1956 +
1957 + while (1) {
1958 + char inbuf[8192];
1959 + char *line = fgets(inbuf, sizeof(inbuf), map);
1960 + if (!line || line[0] == '\0' || !strcmp(line, "done\n")) {
1961 + break;
1962 + }
1963 + int len = strlen(line);
1964 + if (line[len - 1] == '\n') {
1965 + line[len - 1] = '\0';
1966 + if (len == 1) {
1967 + break;
1968 + }
1969 + }
1970 +
1971 + const char *path;
1972 + bool write_zero;
1973 + if (line[0] == '0' && line[1] == ':') {
1974 + path = inbuf + 2;
1975 + write_zero = false;
1976 + } else if (line[0] == '1' && line[1] == ':') {
1977 + path = inbuf + 2;
1978 + write_zero = true;
1979 + } else {
1980 + g_error("read map failed - parse error ('%s')", inbuf);
1981 + }
1982 +
1983 + char *devname = NULL;
1984 + path = extract_devname(path, &devname, -1);
1985 + if (!devname) {
1986 + g_error("read map failed - no dev name specified ('%s')",
1987 + inbuf);
1988 + }
1989 +
1990 + RestoreMap *map = g_new0(RestoreMap, 1);
1991 + map->devname = g_strdup(devname);
1992 + map->path = g_strdup(path);
1993 + map->write_zero = write_zero;
1994 +
1995 + g_hash_table_insert(devmap, map->devname, map);
1996 +
1997 + };
1998 + }
1999 +
2000 + int i;
2001 + int vmstate_fd = -1;
2002 + guint8 vmstate_stream = 0;
2003 +
2004 + for (i = 1; i < 255; i++) {
2005 + VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
2006 + if (di && (strcmp(di->devname, "vmstate") == 0)) {
2007 + vmstate_stream = i;
2008 + char *statefn = g_strdup_printf("%s/vmstate.bin", dirname);
2009 + vmstate_fd = open(statefn, O_WRONLY|O_CREAT|O_EXCL, 0644);
2010 + if (vmstate_fd < 0) {
2011 + g_error("create vmstate file '%s' failed - %s", statefn,
2012 + g_strerror(errno));
2013 + }
2014 + g_free(statefn);
2015 + } else if (di) {
2016 + char *devfn = NULL;
2017 + int flags = BDRV_O_RDWR|BDRV_O_CACHE_WB;
2018 + bool write_zero = true;
2019 +
2020 + if (readmap) {
2021 + RestoreMap *map;
2022 + map = (RestoreMap *)g_hash_table_lookup(devmap, di->devname);
2023 + if (map == NULL) {
2024 + g_error("no device name mapping for %s", di->devname);
2025 + }
2026 + devfn = map->path;
2027 + write_zero = map->write_zero;
2028 + } else {
2029 + devfn = g_strdup_printf("%s/tmp-disk-%s.raw",
2030 + dirname, di->devname);
2031 + printf("DEVINFO %s %zd\n", devfn, di->size);
2032 +
2033 + bdrv_img_create(devfn, "raw", NULL, NULL, NULL, di->size,
2034 + flags, &errp, 0);
2035 + if (errp) {
2036 + g_error("can't create file %s: %s", devfn,
2037 + error_get_pretty(errp));
2038 + }
2039 +
2040 + /* Note: we created an empty file above, so there is no
2041 + * need to write zeroes (so we generate a sparse file)
2042 + */
2043 + write_zero = false;
2044 + }
2045 +
2046 + BlockDriverState *bs = bdrv_new();
2047 + if (errp || bdrv_open(&bs, devfn, NULL, NULL, flags, NULL, &errp)) {
2048 + g_error("can't open file %s - %s", devfn,
2049 + error_get_pretty(errp));
2050 + }
2051 + if (vma_reader_register_bs(vmar, i, bs, write_zero, &errp) < 0) {
2052 + g_error("%s", error_get_pretty(errp));
2053 + }
2054 +
2055 + if (!readmap) {
2056 + g_free(devfn);
2057 + }
2058 + }
2059 + }
2060 +
2061 + if (vma_reader_restore(vmar, vmstate_fd, verbose, &errp) < 0) {
2062 + g_error("restore failed - %s", error_get_pretty(errp));
2063 + }
2064 +
2065 + if (!readmap) {
2066 + for (i = 1; i < 255; i++) {
2067 + VmaDeviceInfo *di = vma_reader_get_device_info(vmar, i);
2068 + if (di && (i != vmstate_stream)) {
2069 + char *tmpfn = g_strdup_printf("%s/tmp-disk-%s.raw",
2070 + dirname, di->devname);
2071 + char *fn = g_strdup_printf("%s/disk-%s.raw",
2072 + dirname, di->devname);
2073 + if (rename(tmpfn, fn) != 0) {
2074 + g_error("rename %s to %s failed - %s",
2075 + tmpfn, fn, g_strerror(errno));
2076 + }
2077 + }
2078 + }
2079 + }
2080 +
2081 + vma_reader_destroy(vmar);
2082 +
2083 + bdrv_close_all();
2084 +
2085 + return ret;
2086 +}
2087 +
2088 +typedef struct BackupJob {
2089 + BlockDriverState *bs;
2090 + int64_t len;
2091 + VmaWriter *vmaw;
2092 + uint8_t dev_id;
2093 +} BackupJob;
2094 +
2095 +#define BACKUP_SECTORS_PER_CLUSTER (VMA_CLUSTER_SIZE / BDRV_SECTOR_SIZE)
2096 +
2097 +static void coroutine_fn backup_run(void *opaque)
2098 +{
2099 + BackupJob *job = (BackupJob *)opaque;
2100 + struct iovec iov;
2101 + QEMUIOVector qiov;
2102 +
2103 + int64_t start, end;
2104 + int ret = 0;
2105 +
2106 + unsigned char *buf = qemu_blockalign(job->bs, VMA_CLUSTER_SIZE);
2107 +
2108 + start = 0;
2109 + end = DIV_ROUND_UP(job->len / BDRV_SECTOR_SIZE,
2110 + BACKUP_SECTORS_PER_CLUSTER);
2111 +
2112 + for (; start < end; start++) {
2113 + iov.iov_base = buf;
2114 + iov.iov_len = VMA_CLUSTER_SIZE;
2115 + qemu_iovec_init_external(&qiov, &iov, 1);
2116 +
2117 + ret = bdrv_co_readv(job->bs, start * BACKUP_SECTORS_PER_CLUSTER,
2118 + BACKUP_SECTORS_PER_CLUSTER, &qiov);
2119 + if (ret < 0) {
2120 + vma_writer_set_error(job->vmaw, "read error", -1);
2121 + goto out;
2122 + }
2123 +
2124 + size_t zb = 0;
2125 + if (vma_writer_write(job->vmaw, job->dev_id, start, buf, &zb) < 0) {
2126 + vma_writer_set_error(job->vmaw, "backup_dump_cb vma_writer_write failed", -1);
2127 + goto out;
2128 + }
2129 + }
2130 +
2131 +
2132 +out:
2133 + if (vma_writer_close_stream(job->vmaw, job->dev_id) <= 0) {
2134 + Error *err = NULL;
2135 + if (vma_writer_close(job->vmaw, &err) != 0) {
2136 + g_warning("vma_writer_close failed %s", error_get_pretty(err));
2137 + }
2138 + }
2139 +}
2140 +
2141 +static int create_archive(int argc, char **argv)
2142 +{
2143 + int i, c, res;
2144 + int verbose = 0;
2145 + const char *archivename;
2146 + GList *config_files = NULL;
2147 +
2148 + for (;;) {
2149 + c = getopt(argc, argv, "hvc:");
2150 + if (c == -1) {
2151 + break;
2152 + }
2153 + switch (c) {
2154 + case '?':
2155 + case 'h':
2156 + help();
2157 + break;
2158 + case 'c':
2159 + config_files = g_list_append(config_files, optarg);
2160 + break;
2161 + case 'v':
2162 + verbose = 1;
2163 + break;
2164 + default:
2165 + g_assert_not_reached();
2166 + }
2167 + }
2168 +
2169 +
2170 + /* make sure we have archive name and at least one path */
2171 + if ((optind + 2) > argc) {
2172 + help();
2173 + }
2174 +
2175 + archivename = argv[optind++];
2176 +
2177 + uuid_t uuid;
2178 + uuid_generate(uuid);
2179 +
2180 + Error *local_err = NULL;
2181 + VmaWriter *vmaw = vma_writer_create(archivename, uuid, &local_err);
2182 +
2183 + if (vmaw == NULL) {
2184 + g_error("%s", error_get_pretty(local_err));
2185 + }
2186 +
2187 + GList *l = config_files;
2188 + while (l && l->data) {
2189 + char *name = l->data;
2190 + char *cdata = NULL;
2191 + gsize clen = 0;
2192 + GError *err = NULL;
2193 + if (!g_file_get_contents(name, &cdata, &clen, &err)) {
2194 + unlink(archivename);
2195 + g_error("Unable to read file: %s", err->message);
2196 + }
2197 +
2198 + if (vma_writer_add_config(vmaw, name, cdata, clen) != 0) {
2199 + unlink(archivename);
2200 + g_error("Unable to append config data %s (len = %zd)",
2201 + name, clen);
2202 + }
2203 + l = g_list_next(l);
2204 + }
2205 +
2206 + int ind = 0;
2207 + while (optind < argc) {
2208 + const char *path = argv[optind++];
2209 + char *devname = NULL;
2210 + path = extract_devname(path, &devname, ind++);
2211 +
2212 + BlockDriver *drv = NULL;
2213 + Error *errp = NULL;
2214 + BlockDriverState *bs = bdrv_new();
2215 +
2216 + res = bdrv_open(&bs, path, NULL, NULL, BDRV_O_CACHE_WB , drv, &errp);
2217 + if (res < 0) {
2218 + unlink(archivename);
2219 + g_error("bdrv_open '%s' failed - %s", path, error_get_pretty(errp));
2220 + }
2221 + int64_t size = bdrv_getlength(bs);
2222 + int dev_id = vma_writer_register_stream(vmaw, devname, size);
2223 + if (dev_id <= 0) {
2224 + unlink(archivename);
2225 + g_error("vma_writer_register_stream '%s' failed", devname);
2226 + }
2227 +
2228 + BackupJob *job = g_new0(BackupJob, 1);
2229 + job->len = size;
2230 + job->bs = bs;
2231 + job->vmaw = vmaw;
2232 + job->dev_id = dev_id;
2233 +
2234 + Coroutine *co = qemu_coroutine_create(backup_run);
2235 + qemu_coroutine_enter(co, job);
2236 + }
2237 +
2238 + VmaStatus vmastat;
2239 + int percent = 0;
2240 + int last_percent = -1;
2241 +
2242 + while (1) {
2243 + main_loop_wait(false);
2244 + vma_writer_get_status(vmaw, &vmastat);
2245 +
2246 + if (verbose) {
2247 +
2248 + uint64_t total = 0;
2249 + uint64_t transferred = 0;
2250 + uint64_t zero_bytes = 0;
2251 +
2252 + int i;
2253 + for (i = 0; i < 256; i++) {
2254 + if (vmastat.stream_info[i].size) {
2255 + total += vmastat.stream_info[i].size;
2256 + transferred += vmastat.stream_info[i].transferred;
2257 + zero_bytes += vmastat.stream_info[i].zero_bytes;
2258 + }
2259 + }
2260 + percent = (transferred*100)/total;
2261 + if (percent != last_percent) {
2262 + fprintf(stderr, "progress %d%% %zd/%zd %zd\n", percent,
2263 + transferred, total, zero_bytes);
2264 + fflush(stderr);
2265 +
2266 + last_percent = percent;
2267 + }
2268 + }
2269 +
2270 + if (vmastat.closed) {
2271 + break;
2272 + }
2273 + }
2274 +
2275 + bdrv_drain_all();
2276 +
2277 + vma_writer_get_status(vmaw, &vmastat);
2278 +
2279 + if (verbose) {
2280 + for (i = 0; i < 256; i++) {
2281 + VmaStreamInfo *si = &vmastat.stream_info[i];
2282 + if (si->size) {
2283 + fprintf(stderr, "image %s: size=%zd zeros=%zd saved=%zd\n",
2284 + si->devname, si->size, si->zero_bytes,
2285 + si->size - si->zero_bytes);
2286 + }
2287 + }
2288 + }
2289 +
2290 + if (vmastat.status < 0) {
2291 + unlink(archivename);
2292 + g_error("creating vma archive failed");
2293 + }
2294 +
2295 + return 0;
2296 +}
2297 +
2298 +int main(int argc, char **argv)
2299 +{
2300 + const char *cmdname;
2301 + Error *main_loop_err = NULL;
2302 +
2303 + error_set_progname(argv[0]);
2304 +
2305 + if (qemu_init_main_loop(&main_loop_err)) {
2306 + g_error("%s", error_get_pretty(main_loop_err));
2307 + }
2308 +
2309 + bdrv_init();
2310 +
2311 + if (argc < 2) {
2312 + help();
2313 + }
2314 +
2315 + cmdname = argv[1];
2316 + argc--; argv++;
2317 +
2318 +
2319 + if (!strcmp(cmdname, "list")) {
2320 + return list_content(argc, argv);
2321 + } else if (!strcmp(cmdname, "create")) {
2322 + return create_archive(argc, argv);
2323 + } else if (!strcmp(cmdname, "extract")) {
2324 + return extract_content(argc, argv);
2325 + }
2326 +
2327 + help();
2328 + return 0;
2329 +}
2330 diff --git a/vma.h b/vma.h
2331 new file mode 100644
2332 index 0000000..6625eb9
2333 --- /dev/null
2334 +++ b/vma.h
2335 @@ -0,0 +1,146 @@
2336 +/*
2337 + * VMA: Virtual Machine Archive
2338 + *
2339 + * Copyright (C) Proxmox Server Solutions
2340 + *
2341 + * Authors:
2342 + * Dietmar Maurer (dietmar@proxmox.com)
2343 + *
2344 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
2345 + * See the COPYING file in the top-level directory.
2346 + *
2347 + */
2348 +
2349 +#ifndef BACKUP_VMA_H
2350 +#define BACKUP_VMA_H
2351 +
2352 +#include <uuid/uuid.h>
2353 +#include "qapi/error.h"
2354 +#include "block/block.h"
2355 +
2356 +#define VMA_BLOCK_BITS 12
2357 +#define VMA_BLOCK_SIZE (1<<VMA_BLOCK_BITS)
2358 +#define VMA_CLUSTER_BITS (VMA_BLOCK_BITS+4)
2359 +#define VMA_CLUSTER_SIZE (1<<VMA_CLUSTER_BITS)
2360 +
2361 +#if VMA_CLUSTER_SIZE != 65536
2362 +#error unexpected cluster size
2363 +#endif
2364 +
2365 +#define VMA_EXTENT_HEADER_SIZE 512
2366 +#define VMA_BLOCKS_PER_EXTENT 59
2367 +#define VMA_MAX_CONFIGS 256
2368 +
2369 +#define VMA_MAX_EXTENT_SIZE \
2370 + (VMA_EXTENT_HEADER_SIZE+VMA_CLUSTER_SIZE*VMA_BLOCKS_PER_EXTENT)
2371 +#if VMA_MAX_EXTENT_SIZE != 3867136
2372 +#error unexpected VMA_EXTENT_SIZE
2373 +#endif
2374 +
2375 +/* File Format Definitions */
2376 +
2377 +#define VMA_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|0x00))
2378 +#define VMA_EXTENT_MAGIC (GUINT32_TO_BE(('V'<<24)|('M'<<16)|('A'<<8)|'E'))
2379 +
2380 +typedef struct VmaDeviceInfoHeader {
2381 + uint32_t devname_ptr; /* offset into blob_buffer table */
2382 + uint32_t reserved0;
2383 + uint64_t size; /* device size in bytes */
2384 + uint64_t reserved1;
2385 + uint64_t reserved2;
2386 +} VmaDeviceInfoHeader;
2387 +
2388 +typedef struct VmaHeader {
2389 + uint32_t magic;
2390 + uint32_t version;
2391 + unsigned char uuid[16];
2392 + int64_t ctime;
2393 + unsigned char md5sum[16];
2394 +
2395 + uint32_t blob_buffer_offset;
2396 + uint32_t blob_buffer_size;
2397 + uint32_t header_size;
2398 +
2399 + unsigned char reserved[1984];
2400 +
2401 + uint32_t config_names[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
2402 + uint32_t config_data[VMA_MAX_CONFIGS]; /* offset into blob_buffer table */
2403 +
2404 + uint32_t reserved1;
2405 +
2406 + VmaDeviceInfoHeader dev_info[256];
2407 +} VmaHeader;
2408 +
2409 +typedef struct VmaExtentHeader {
2410 + uint32_t magic;
2411 + uint16_t reserved1;
2412 + uint16_t block_count;
2413 + unsigned char uuid[16];
2414 + unsigned char md5sum[16];
2415 + uint64_t blockinfo[VMA_BLOCKS_PER_EXTENT];
2416 +} VmaExtentHeader;
2417 +
2418 +/* functions/definitions to read/write vma files */
2419 +
2420 +typedef struct VmaReader VmaReader;
2421 +
2422 +typedef struct VmaWriter VmaWriter;
2423 +
2424 +typedef struct VmaConfigData {
2425 + const char *name;
2426 + const void *data;
2427 + uint32_t len;
2428 +} VmaConfigData;
2429 +
2430 +typedef struct VmaStreamInfo {
2431 + uint64_t size;
2432 + uint64_t cluster_count;
2433 + uint64_t transferred;
2434 + uint64_t zero_bytes;
2435 + int finished;
2436 + char *devname;
2437 +} VmaStreamInfo;
2438 +
2439 +typedef struct VmaStatus {
2440 + int status;
2441 + bool closed;
2442 + char errmsg[8192];
2443 + char uuid_str[37];
2444 + VmaStreamInfo stream_info[256];
2445 +} VmaStatus;
2446 +
2447 +typedef struct VmaDeviceInfo {
2448 + uint64_t size; /* device size in bytes */
2449 + const char *devname;
2450 +} VmaDeviceInfo;
2451 +
2452 +VmaWriter *vma_writer_create(const char *filename, uuid_t uuid, Error **errp);
2453 +int vma_writer_close(VmaWriter *vmaw, Error **errp);
2454 +void vma_writer_destroy(VmaWriter *vmaw);
2455 +int vma_writer_add_config(VmaWriter *vmaw, const char *name, gpointer data,
2456 + size_t len);
2457 +int vma_writer_register_stream(VmaWriter *vmaw, const char *devname,
2458 + size_t size);
2459 +
2460 +int64_t coroutine_fn vma_writer_write(VmaWriter *vmaw, uint8_t dev_id,
2461 + int64_t cluster_num, unsigned char *buf,
2462 + size_t *zero_bytes);
2463 +
2464 +int coroutine_fn vma_writer_close_stream(VmaWriter *vmaw, uint8_t dev_id);
2465 +
2466 +int vma_writer_get_status(VmaWriter *vmaw, VmaStatus *status);
2467 +void vma_writer_set_error(VmaWriter *vmaw, const char *fmt, ...);
2468 +
2469 +
2470 +VmaReader *vma_reader_create(const char *filename, Error **errp);
2471 +void vma_reader_destroy(VmaReader *vmar);
2472 +VmaHeader *vma_reader_get_header(VmaReader *vmar);
2473 +GList *vma_reader_get_config_data(VmaReader *vmar);
2474 +VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id);
2475 +int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id,
2476 + BlockDriverState *bs, bool write_zeroes,
2477 + Error **errp);
2478 +int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
2479 + Error **errp);
2480 +
2481 +#endif /* BACKUP_VMA_H */
2482 --
2483 2.1.4