1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26
27#include "block/qdict.h"
28#include "sysemu/block-backend.h"
29#include "qemu/main-loop.h"
30#include "qemu/module.h"
31#include "qcow2.h"
32#include "qemu/error-report.h"
33#include "qapi/error.h"
34#include "qapi/qapi-events-block-core.h"
35#include "qapi/qmp/qdict.h"
36#include "qapi/qmp/qstring.h"
37#include "trace.h"
38#include "qemu/option_int.h"
39#include "qemu/cutils.h"
40#include "qemu/bswap.h"
41#include "qemu/memalign.h"
42#include "qapi/qobject-input-visitor.h"
43#include "qapi/qapi-visit-block-core.h"
44#include "crypto.h"
45#include "block/aio_task.h"
46#include "block/dirty-bitmap.h"
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65typedef struct {
66 uint32_t magic;
67 uint32_t len;
68} QEMU_PACKED QCowExtension;
69
70#define QCOW2_EXT_MAGIC_END 0
71#define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xe2792aca
72#define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
73#define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
74#define QCOW2_EXT_MAGIC_BITMAPS 0x23852875
75#define QCOW2_EXT_MAGIC_DATA_FILE 0x44415441
76
77static int coroutine_fn
78qcow2_co_preadv_compressed(BlockDriverState *bs,
79 uint64_t l2_entry,
80 uint64_t offset,
81 uint64_t bytes,
82 QEMUIOVector *qiov,
83 size_t qiov_offset);
84
85static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
86{
87 const QCowHeader *cow_header = (const void *)buf;
88
89 if (buf_size >= sizeof(QCowHeader) &&
90 be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&
91 be32_to_cpu(cow_header->version) >= 2)
92 return 100;
93 else
94 return 0;
95}
96
97
98static int qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
99 uint8_t *buf, size_t buflen,
100 void *opaque, Error **errp)
101{
102 BlockDriverState *bs = opaque;
103 BDRVQcow2State *s = bs->opaque;
104 ssize_t ret;
105
106 if ((offset + buflen) > s->crypto_header.length) {
107 error_setg(errp, "Request for data outside of extension header");
108 return -1;
109 }
110
111 ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buflen, buf,
112 0);
113 if (ret < 0) {
114 error_setg_errno(errp, -ret, "Could not read encryption header");
115 return -1;
116 }
117 return 0;
118}
119
120
121static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
122 void *opaque, Error **errp)
123{
124 BlockDriverState *bs = opaque;
125 BDRVQcow2State *s = bs->opaque;
126 int64_t ret;
127 int64_t clusterlen;
128
129 ret = qcow2_alloc_clusters(bs, headerlen);
130 if (ret < 0) {
131 error_setg_errno(errp, -ret,
132 "Cannot allocate cluster for LUKS header size %zu",
133 headerlen);
134 return -1;
135 }
136
137 s->crypto_header.length = headerlen;
138 s->crypto_header.offset = ret;
139
140
141
142
143
144
145 clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
146 assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
147 ret = bdrv_pwrite_zeroes(bs->file,
148 ret,
149 clusterlen, 0);
150 if (ret < 0) {
151 error_setg_errno(errp, -ret, "Could not zero fill encryption header");
152 return -1;
153 }
154
155 return 0;
156}
157
158
159static int qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
160 const uint8_t *buf, size_t buflen,
161 void *opaque, Error **errp)
162{
163 BlockDriverState *bs = opaque;
164 BDRVQcow2State *s = bs->opaque;
165 ssize_t ret;
166
167 if ((offset + buflen) > s->crypto_header.length) {
168 error_setg(errp, "Request for data outside of extension header");
169 return -1;
170 }
171
172 ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buflen, buf,
173 0);
174 if (ret < 0) {
175 error_setg_errno(errp, -ret, "Could not read encryption header");
176 return -1;
177 }
178 return 0;
179}
180
181static QDict*
182qcow2_extract_crypto_opts(QemuOpts *opts, const char *fmt, Error **errp)
183{
184 QDict *cryptoopts_qdict;
185 QDict *opts_qdict;
186
187
188 opts_qdict = qemu_opts_to_qdict(opts, NULL);
189 qdict_extract_subqdict(opts_qdict, &cryptoopts_qdict, "encrypt.");
190 qobject_unref(opts_qdict);
191 qdict_put_str(cryptoopts_qdict, "format", fmt);
192 return cryptoopts_qdict;
193}
194
195
196
197
198
199
200
201
202static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
203 uint64_t end_offset, void **p_feature_table,
204 int flags, bool *need_update_header,
205 Error **errp)
206{
207 BDRVQcow2State *s = bs->opaque;
208 QCowExtension ext;
209 uint64_t offset;
210 int ret;
211 Qcow2BitmapHeaderExt bitmaps_ext;
212
213 if (need_update_header != NULL) {
214 *need_update_header = false;
215 }
216
217#ifdef DEBUG_EXT
218 printf("qcow2_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
219#endif
220 offset = start_offset;
221 while (offset < end_offset) {
222
223#ifdef DEBUG_EXT
224
225 if (offset > s->cluster_size)
226 printf("qcow2_read_extension: suspicious offset %lu\n", offset);
227
228 printf("attempting to read extended header in offset %lu\n", offset);
229#endif
230
231 ret = bdrv_pread(bs->file, offset, sizeof(ext), &ext, 0);
232 if (ret < 0) {
233 error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
234 "pread fail from offset %" PRIu64, offset);
235 return 1;
236 }
237 ext.magic = be32_to_cpu(ext.magic);
238 ext.len = be32_to_cpu(ext.len);
239 offset += sizeof(ext);
240#ifdef DEBUG_EXT
241 printf("ext.magic = 0x%x\n", ext.magic);
242#endif
243 if (offset > end_offset || ext.len > end_offset - offset) {
244 error_setg(errp, "Header extension too large");
245 return -EINVAL;
246 }
247
248 switch (ext.magic) {
249 case QCOW2_EXT_MAGIC_END:
250 return 0;
251
252 case QCOW2_EXT_MAGIC_BACKING_FORMAT:
253 if (ext.len >= sizeof(bs->backing_format)) {
254 error_setg(errp, "ERROR: ext_backing_format: len=%" PRIu32
255 " too large (>=%zu)", ext.len,
256 sizeof(bs->backing_format));
257 return 2;
258 }
259 ret = bdrv_pread(bs->file, offset, ext.len, bs->backing_format, 0);
260 if (ret < 0) {
261 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
262 "Could not read format name");
263 return 3;
264 }
265 bs->backing_format[ext.len] = '\0';
266 s->image_backing_format = g_strdup(bs->backing_format);
267#ifdef DEBUG_EXT
268 printf("Qcow2: Got format extension %s\n", bs->backing_format);
269#endif
270 break;
271
272 case QCOW2_EXT_MAGIC_FEATURE_TABLE:
273 if (p_feature_table != NULL) {
274 void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
275 ret = bdrv_pread(bs->file, offset, ext.len, feature_table, 0);
276 if (ret < 0) {
277 error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
278 "Could not read table");
279 g_free(feature_table);
280 return ret;
281 }
282
283 *p_feature_table = feature_table;
284 }
285 break;
286
287 case QCOW2_EXT_MAGIC_CRYPTO_HEADER: {
288 unsigned int cflags = 0;
289 if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
290 error_setg(errp, "CRYPTO header extension only "
291 "expected with LUKS encryption method");
292 return -EINVAL;
293 }
294 if (ext.len != sizeof(Qcow2CryptoHeaderExtension)) {
295 error_setg(errp, "CRYPTO header extension size %u, "
296 "but expected size %zu", ext.len,
297 sizeof(Qcow2CryptoHeaderExtension));
298 return -EINVAL;
299 }
300
301 ret = bdrv_pread(bs->file, offset, ext.len, &s->crypto_header, 0);
302 if (ret < 0) {
303 error_setg_errno(errp, -ret,
304 "Unable to read CRYPTO header extension");
305 return ret;
306 }
307 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
308 s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
309
310 if ((s->crypto_header.offset % s->cluster_size) != 0) {
311 error_setg(errp, "Encryption header offset '%" PRIu64 "' is "
312 "not a multiple of cluster size '%u'",
313 s->crypto_header.offset, s->cluster_size);
314 return -EINVAL;
315 }
316
317 if (flags & BDRV_O_NO_IO) {
318 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
319 }
320 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
321 qcow2_crypto_hdr_read_func,
322 bs, cflags, QCOW2_MAX_THREADS, errp);
323 if (!s->crypto) {
324 return -EINVAL;
325 }
326 } break;
327
328 case QCOW2_EXT_MAGIC_BITMAPS:
329 if (ext.len != sizeof(bitmaps_ext)) {
330 error_setg_errno(errp, -ret, "bitmaps_ext: "
331 "Invalid extension length");
332 return -EINVAL;
333 }
334
335 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) {
336 if (s->qcow_version < 3) {
337
338 warn_report("This qcow2 v2 image contains bitmaps, but "
339 "they may have been modified by a program "
340 "without persistent bitmap support; so now "
341 "they must all be considered inconsistent");
342 } else {
343 warn_report("a program lacking bitmap support "
344 "modified this file, so all bitmaps are now "
345 "considered inconsistent");
346 }
347 error_printf("Some clusters may be leaked, "
348 "run 'qemu-img check -r' on the image "
349 "file to fix.");
350 if (need_update_header != NULL) {
351
352 *need_update_header = true;
353 }
354 break;
355 }
356
357 ret = bdrv_pread(bs->file, offset, ext.len, &bitmaps_ext, 0);
358 if (ret < 0) {
359 error_setg_errno(errp, -ret, "bitmaps_ext: "
360 "Could not read ext header");
361 return ret;
362 }
363
364 if (bitmaps_ext.reserved32 != 0) {
365 error_setg_errno(errp, -ret, "bitmaps_ext: "
366 "Reserved field is not zero");
367 return -EINVAL;
368 }
369
370 bitmaps_ext.nb_bitmaps = be32_to_cpu(bitmaps_ext.nb_bitmaps);
371 bitmaps_ext.bitmap_directory_size =
372 be64_to_cpu(bitmaps_ext.bitmap_directory_size);
373 bitmaps_ext.bitmap_directory_offset =
374 be64_to_cpu(bitmaps_ext.bitmap_directory_offset);
375
376 if (bitmaps_ext.nb_bitmaps > QCOW2_MAX_BITMAPS) {
377 error_setg(errp,
378 "bitmaps_ext: Image has %" PRIu32 " bitmaps, "
379 "exceeding the QEMU supported maximum of %d",
380 bitmaps_ext.nb_bitmaps, QCOW2_MAX_BITMAPS);
381 return -EINVAL;
382 }
383
384 if (bitmaps_ext.nb_bitmaps == 0) {
385 error_setg(errp, "found bitmaps extension with zero bitmaps");
386 return -EINVAL;
387 }
388
389 if (offset_into_cluster(s, bitmaps_ext.bitmap_directory_offset)) {
390 error_setg(errp, "bitmaps_ext: "
391 "invalid bitmap directory offset");
392 return -EINVAL;
393 }
394
395 if (bitmaps_ext.bitmap_directory_size >
396 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
397 error_setg(errp, "bitmaps_ext: "
398 "bitmap directory size (%" PRIu64 ") exceeds "
399 "the maximum supported size (%d)",
400 bitmaps_ext.bitmap_directory_size,
401 QCOW2_MAX_BITMAP_DIRECTORY_SIZE);
402 return -EINVAL;
403 }
404
405 s->nb_bitmaps = bitmaps_ext.nb_bitmaps;
406 s->bitmap_directory_offset =
407 bitmaps_ext.bitmap_directory_offset;
408 s->bitmap_directory_size =
409 bitmaps_ext.bitmap_directory_size;
410
411#ifdef DEBUG_EXT
412 printf("Qcow2: Got bitmaps extension: "
413 "offset=%" PRIu64 " nb_bitmaps=%" PRIu32 "\n",
414 s->bitmap_directory_offset, s->nb_bitmaps);
415#endif
416 break;
417
418 case QCOW2_EXT_MAGIC_DATA_FILE:
419 {
420 s->image_data_file = g_malloc0(ext.len + 1);
421 ret = bdrv_pread(bs->file, offset, ext.len, s->image_data_file, 0);
422 if (ret < 0) {
423 error_setg_errno(errp, -ret,
424 "ERROR: Could not read data file name");
425 return ret;
426 }
427#ifdef DEBUG_EXT
428 printf("Qcow2: Got external data file %s\n", s->image_data_file);
429#endif
430 break;
431 }
432
433 default:
434
435
436
437 {
438 Qcow2UnknownHeaderExtension *uext;
439
440 uext = g_malloc0(sizeof(*uext) + ext.len);
441 uext->magic = ext.magic;
442 uext->len = ext.len;
443 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
444
445 ret = bdrv_pread(bs->file, offset, uext->len, uext->data, 0);
446 if (ret < 0) {
447 error_setg_errno(errp, -ret, "ERROR: unknown extension: "
448 "Could not read data");
449 return ret;
450 }
451 }
452 break;
453 }
454
455 offset += ((ext.len + 7) & ~7);
456 }
457
458 return 0;
459}
460
461static void cleanup_unknown_header_ext(BlockDriverState *bs)
462{
463 BDRVQcow2State *s = bs->opaque;
464 Qcow2UnknownHeaderExtension *uext, *next;
465
466 QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) {
467 QLIST_REMOVE(uext, next);
468 g_free(uext);
469 }
470}
471
472static void report_unsupported_feature(Error **errp, Qcow2Feature *table,
473 uint64_t mask)
474{
475 g_autoptr(GString) features = g_string_sized_new(60);
476
477 while (table && table->name[0] != '\0') {
478 if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
479 if (mask & (1ULL << table->bit)) {
480 if (features->len > 0) {
481 g_string_append(features, ", ");
482 }
483 g_string_append_printf(features, "%.46s", table->name);
484 mask &= ~(1ULL << table->bit);
485 }
486 }
487 table++;
488 }
489
490 if (mask) {
491 if (features->len > 0) {
492 g_string_append(features, ", ");
493 }
494 g_string_append_printf(features,
495 "Unknown incompatible feature: %" PRIx64, mask);
496 }
497
498 error_setg(errp, "Unsupported qcow2 feature(s): %s", features->str);
499}
500
501
502
503
504
505
506
507
508int qcow2_mark_dirty(BlockDriverState *bs)
509{
510 BDRVQcow2State *s = bs->opaque;
511 uint64_t val;
512 int ret;
513
514 assert(s->qcow_version >= 3);
515
516 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
517 return 0;
518 }
519
520 val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
521 ret = bdrv_pwrite_sync(bs->file,
522 offsetof(QCowHeader, incompatible_features),
523 sizeof(val), &val, 0);
524 if (ret < 0) {
525 return ret;
526 }
527
528
529 s->incompatible_features |= QCOW2_INCOMPAT_DIRTY;
530 return 0;
531}
532
533
534
535
536
537
538static int qcow2_mark_clean(BlockDriverState *bs)
539{
540 BDRVQcow2State *s = bs->opaque;
541
542 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
543 int ret;
544
545 s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY;
546
547 ret = qcow2_flush_caches(bs);
548 if (ret < 0) {
549 return ret;
550 }
551
552 return qcow2_update_header(bs);
553 }
554 return 0;
555}
556
557
558
559
560int qcow2_mark_corrupt(BlockDriverState *bs)
561{
562 BDRVQcow2State *s = bs->opaque;
563
564 s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT;
565 return qcow2_update_header(bs);
566}
567
568
569
570
571
572int qcow2_mark_consistent(BlockDriverState *bs)
573{
574 BDRVQcow2State *s = bs->opaque;
575
576 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
577 int ret = qcow2_flush_caches(bs);
578 if (ret < 0) {
579 return ret;
580 }
581
582 s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT;
583 return qcow2_update_header(bs);
584 }
585 return 0;
586}
587
588static void qcow2_add_check_result(BdrvCheckResult *out,
589 const BdrvCheckResult *src,
590 bool set_allocation_info)
591{
592 out->corruptions += src->corruptions;
593 out->leaks += src->leaks;
594 out->check_errors += src->check_errors;
595 out->corruptions_fixed += src->corruptions_fixed;
596 out->leaks_fixed += src->leaks_fixed;
597
598 if (set_allocation_info) {
599 out->image_end_offset = src->image_end_offset;
600 out->bfi = src->bfi;
601 }
602}
603
604static int coroutine_fn GRAPH_RDLOCK
605qcow2_co_check_locked(BlockDriverState *bs, BdrvCheckResult *result,
606 BdrvCheckMode fix)
607{
608 BdrvCheckResult snapshot_res = {};
609 BdrvCheckResult refcount_res = {};
610 int ret;
611
612 memset(result, 0, sizeof(*result));
613
614 ret = qcow2_check_read_snapshot_table(bs, &snapshot_res, fix);
615 if (ret < 0) {
616 qcow2_add_check_result(result, &snapshot_res, false);
617 return ret;
618 }
619
620 ret = qcow2_check_refcounts(bs, &refcount_res, fix);
621 qcow2_add_check_result(result, &refcount_res, true);
622 if (ret < 0) {
623 qcow2_add_check_result(result, &snapshot_res, false);
624 return ret;
625 }
626
627 ret = qcow2_check_fix_snapshot_table(bs, &snapshot_res, fix);
628 qcow2_add_check_result(result, &snapshot_res, false);
629 if (ret < 0) {
630 return ret;
631 }
632
633 if (fix && result->check_errors == 0 && result->corruptions == 0) {
634 ret = qcow2_mark_clean(bs);
635 if (ret < 0) {
636 return ret;
637 }
638 return qcow2_mark_consistent(bs);
639 }
640 return ret;
641}
642
643static int coroutine_fn GRAPH_RDLOCK
644qcow2_co_check(BlockDriverState *bs, BdrvCheckResult *result,
645 BdrvCheckMode fix)
646{
647 BDRVQcow2State *s = bs->opaque;
648 int ret;
649
650 qemu_co_mutex_lock(&s->lock);
651 ret = qcow2_co_check_locked(bs, result, fix);
652 qemu_co_mutex_unlock(&s->lock);
653 return ret;
654}
655
656int qcow2_validate_table(BlockDriverState *bs, uint64_t offset,
657 uint64_t entries, size_t entry_len,
658 int64_t max_size_bytes, const char *table_name,
659 Error **errp)
660{
661 BDRVQcow2State *s = bs->opaque;
662
663 if (entries > max_size_bytes / entry_len) {
664 error_setg(errp, "%s too large", table_name);
665 return -EFBIG;
666 }
667
668
669
670 if ((INT64_MAX - entries * entry_len < offset) ||
671 (offset_into_cluster(s, offset) != 0)) {
672 error_setg(errp, "%s offset invalid", table_name);
673 return -EINVAL;
674 }
675
676 return 0;
677}
678
679static const char *const mutable_opts[] = {
680 QCOW2_OPT_LAZY_REFCOUNTS,
681 QCOW2_OPT_DISCARD_REQUEST,
682 QCOW2_OPT_DISCARD_SNAPSHOT,
683 QCOW2_OPT_DISCARD_OTHER,
684 QCOW2_OPT_OVERLAP,
685 QCOW2_OPT_OVERLAP_TEMPLATE,
686 QCOW2_OPT_OVERLAP_MAIN_HEADER,
687 QCOW2_OPT_OVERLAP_ACTIVE_L1,
688 QCOW2_OPT_OVERLAP_ACTIVE_L2,
689 QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
690 QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
691 QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
692 QCOW2_OPT_OVERLAP_INACTIVE_L1,
693 QCOW2_OPT_OVERLAP_INACTIVE_L2,
694 QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
695 QCOW2_OPT_CACHE_SIZE,
696 QCOW2_OPT_L2_CACHE_SIZE,
697 QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
698 QCOW2_OPT_REFCOUNT_CACHE_SIZE,
699 QCOW2_OPT_CACHE_CLEAN_INTERVAL,
700 NULL
701};
702
703static QemuOptsList qcow2_runtime_opts = {
704 .name = "qcow2",
705 .head = QTAILQ_HEAD_INITIALIZER(qcow2_runtime_opts.head),
706 .desc = {
707 {
708 .name = QCOW2_OPT_LAZY_REFCOUNTS,
709 .type = QEMU_OPT_BOOL,
710 .help = "Postpone refcount updates",
711 },
712 {
713 .name = QCOW2_OPT_DISCARD_REQUEST,
714 .type = QEMU_OPT_BOOL,
715 .help = "Pass guest discard requests to the layer below",
716 },
717 {
718 .name = QCOW2_OPT_DISCARD_SNAPSHOT,
719 .type = QEMU_OPT_BOOL,
720 .help = "Generate discard requests when snapshot related space "
721 "is freed",
722 },
723 {
724 .name = QCOW2_OPT_DISCARD_OTHER,
725 .type = QEMU_OPT_BOOL,
726 .help = "Generate discard requests when other clusters are freed",
727 },
728 {
729 .name = QCOW2_OPT_OVERLAP,
730 .type = QEMU_OPT_STRING,
731 .help = "Selects which overlap checks to perform from a range of "
732 "templates (none, constant, cached, all)",
733 },
734 {
735 .name = QCOW2_OPT_OVERLAP_TEMPLATE,
736 .type = QEMU_OPT_STRING,
737 .help = "Selects which overlap checks to perform from a range of "
738 "templates (none, constant, cached, all)",
739 },
740 {
741 .name = QCOW2_OPT_OVERLAP_MAIN_HEADER,
742 .type = QEMU_OPT_BOOL,
743 .help = "Check for unintended writes into the main qcow2 header",
744 },
745 {
746 .name = QCOW2_OPT_OVERLAP_ACTIVE_L1,
747 .type = QEMU_OPT_BOOL,
748 .help = "Check for unintended writes into the active L1 table",
749 },
750 {
751 .name = QCOW2_OPT_OVERLAP_ACTIVE_L2,
752 .type = QEMU_OPT_BOOL,
753 .help = "Check for unintended writes into an active L2 table",
754 },
755 {
756 .name = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
757 .type = QEMU_OPT_BOOL,
758 .help = "Check for unintended writes into the refcount table",
759 },
760 {
761 .name = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
762 .type = QEMU_OPT_BOOL,
763 .help = "Check for unintended writes into a refcount block",
764 },
765 {
766 .name = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
767 .type = QEMU_OPT_BOOL,
768 .help = "Check for unintended writes into the snapshot table",
769 },
770 {
771 .name = QCOW2_OPT_OVERLAP_INACTIVE_L1,
772 .type = QEMU_OPT_BOOL,
773 .help = "Check for unintended writes into an inactive L1 table",
774 },
775 {
776 .name = QCOW2_OPT_OVERLAP_INACTIVE_L2,
777 .type = QEMU_OPT_BOOL,
778 .help = "Check for unintended writes into an inactive L2 table",
779 },
780 {
781 .name = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
782 .type = QEMU_OPT_BOOL,
783 .help = "Check for unintended writes into the bitmap directory",
784 },
785 {
786 .name = QCOW2_OPT_CACHE_SIZE,
787 .type = QEMU_OPT_SIZE,
788 .help = "Maximum combined metadata (L2 tables and refcount blocks) "
789 "cache size",
790 },
791 {
792 .name = QCOW2_OPT_L2_CACHE_SIZE,
793 .type = QEMU_OPT_SIZE,
794 .help = "Maximum L2 table cache size",
795 },
796 {
797 .name = QCOW2_OPT_L2_CACHE_ENTRY_SIZE,
798 .type = QEMU_OPT_SIZE,
799 .help = "Size of each entry in the L2 cache",
800 },
801 {
802 .name = QCOW2_OPT_REFCOUNT_CACHE_SIZE,
803 .type = QEMU_OPT_SIZE,
804 .help = "Maximum refcount block cache size",
805 },
806 {
807 .name = QCOW2_OPT_CACHE_CLEAN_INTERVAL,
808 .type = QEMU_OPT_NUMBER,
809 .help = "Clean unused cache entries after this time (in seconds)",
810 },
811 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.",
812 "ID of secret providing qcow2 AES key or LUKS passphrase"),
813 { }
814 },
815};
816
817static const char *overlap_bool_option_names[QCOW2_OL_MAX_BITNR] = {
818 [QCOW2_OL_MAIN_HEADER_BITNR] = QCOW2_OPT_OVERLAP_MAIN_HEADER,
819 [QCOW2_OL_ACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L1,
820 [QCOW2_OL_ACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_ACTIVE_L2,
821 [QCOW2_OL_REFCOUNT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_TABLE,
822 [QCOW2_OL_REFCOUNT_BLOCK_BITNR] = QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK,
823 [QCOW2_OL_SNAPSHOT_TABLE_BITNR] = QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE,
824 [QCOW2_OL_INACTIVE_L1_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L1,
825 [QCOW2_OL_INACTIVE_L2_BITNR] = QCOW2_OPT_OVERLAP_INACTIVE_L2,
826 [QCOW2_OL_BITMAP_DIRECTORY_BITNR] = QCOW2_OPT_OVERLAP_BITMAP_DIRECTORY,
827};
828
829static void cache_clean_timer_cb(void *opaque)
830{
831 BlockDriverState *bs = opaque;
832 BDRVQcow2State *s = bs->opaque;
833 qcow2_cache_clean_unused(s->l2_table_cache);
834 qcow2_cache_clean_unused(s->refcount_block_cache);
835 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
836 (int64_t) s->cache_clean_interval * 1000);
837}
838
839static void cache_clean_timer_init(BlockDriverState *bs, AioContext *context)
840{
841 BDRVQcow2State *s = bs->opaque;
842 if (s->cache_clean_interval > 0) {
843 s->cache_clean_timer =
844 aio_timer_new_with_attrs(context, QEMU_CLOCK_VIRTUAL,
845 SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
846 cache_clean_timer_cb, bs);
847 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
848 (int64_t) s->cache_clean_interval * 1000);
849 }
850}
851
852static void cache_clean_timer_del(BlockDriverState *bs)
853{
854 BDRVQcow2State *s = bs->opaque;
855 if (s->cache_clean_timer) {
856 timer_free(s->cache_clean_timer);
857 s->cache_clean_timer = NULL;
858 }
859}
860
861static void qcow2_detach_aio_context(BlockDriverState *bs)
862{
863 cache_clean_timer_del(bs);
864}
865
866static void qcow2_attach_aio_context(BlockDriverState *bs,
867 AioContext *new_context)
868{
869 cache_clean_timer_init(bs, new_context);
870}
871
872static bool read_cache_sizes(BlockDriverState *bs, QemuOpts *opts,
873 uint64_t *l2_cache_size,
874 uint64_t *l2_cache_entry_size,
875 uint64_t *refcount_cache_size, Error **errp)
876{
877 BDRVQcow2State *s = bs->opaque;
878 uint64_t combined_cache_size, l2_cache_max_setting;
879 bool l2_cache_size_set, refcount_cache_size_set, combined_cache_size_set;
880 bool l2_cache_entry_size_set;
881 int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size;
882 uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE;
883 uint64_t max_l2_entries = DIV_ROUND_UP(virtual_disk_size, s->cluster_size);
884
885
886 uint64_t max_l2_cache = ROUND_UP(max_l2_entries * l2_entry_size(s),
887 s->cluster_size);
888
889 combined_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_CACHE_SIZE);
890 l2_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_SIZE);
891 refcount_cache_size_set = qemu_opt_get(opts, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
892 l2_cache_entry_size_set = qemu_opt_get(opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE);
893
894 combined_cache_size = qemu_opt_get_size(opts, QCOW2_OPT_CACHE_SIZE, 0);
895 l2_cache_max_setting = qemu_opt_get_size(opts, QCOW2_OPT_L2_CACHE_SIZE,
896 DEFAULT_L2_CACHE_MAX_SIZE);
897 *refcount_cache_size = qemu_opt_get_size(opts,
898 QCOW2_OPT_REFCOUNT_CACHE_SIZE, 0);
899
900 *l2_cache_entry_size = qemu_opt_get_size(
901 opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE, s->cluster_size);
902
903 *l2_cache_size = MIN(max_l2_cache, l2_cache_max_setting);
904
905 if (combined_cache_size_set) {
906 if (l2_cache_size_set && refcount_cache_size_set) {
907 error_setg(errp, QCOW2_OPT_CACHE_SIZE ", " QCOW2_OPT_L2_CACHE_SIZE
908 " and " QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not be set "
909 "at the same time");
910 return false;
911 } else if (l2_cache_size_set &&
912 (l2_cache_max_setting > combined_cache_size)) {
913 error_setg(errp, QCOW2_OPT_L2_CACHE_SIZE " may not exceed "
914 QCOW2_OPT_CACHE_SIZE);
915 return false;
916 } else if (*refcount_cache_size > combined_cache_size) {
917 error_setg(errp, QCOW2_OPT_REFCOUNT_CACHE_SIZE " may not exceed "
918 QCOW2_OPT_CACHE_SIZE);
919 return false;
920 }
921
922 if (l2_cache_size_set) {
923 *refcount_cache_size = combined_cache_size - *l2_cache_size;
924 } else if (refcount_cache_size_set) {
925 *l2_cache_size = combined_cache_size - *refcount_cache_size;
926 } else {
927
928
929 if (combined_cache_size >= max_l2_cache + min_refcount_cache) {
930 *l2_cache_size = max_l2_cache;
931 *refcount_cache_size = combined_cache_size - *l2_cache_size;
932 } else {
933 *refcount_cache_size =
934 MIN(combined_cache_size, min_refcount_cache);
935 *l2_cache_size = combined_cache_size - *refcount_cache_size;
936 }
937 }
938 }
939
940
941
942
943
944
945 if (*l2_cache_size < max_l2_cache && !l2_cache_entry_size_set) {
946 *l2_cache_entry_size = MIN(s->cluster_size, 4096);
947 }
948
949
950
951
952 if (*l2_cache_entry_size < (1 << MIN_CLUSTER_BITS) ||
953 *l2_cache_entry_size > s->cluster_size ||
954 !is_power_of_2(*l2_cache_entry_size)) {
955 error_setg(errp, "L2 cache entry size must be a power of two "
956 "between %d and the cluster size (%d)",
957 1 << MIN_CLUSTER_BITS, s->cluster_size);
958 return false;
959 }
960
961 return true;
962}
963
964typedef struct Qcow2ReopenState {
965 Qcow2Cache *l2_table_cache;
966 Qcow2Cache *refcount_block_cache;
967 int l2_slice_size;
968 bool use_lazy_refcounts;
969 int overlap_check;
970 bool discard_passthrough[QCOW2_DISCARD_MAX];
971 uint64_t cache_clean_interval;
972 QCryptoBlockOpenOptions *crypto_opts;
973} Qcow2ReopenState;
974
975static int qcow2_update_options_prepare(BlockDriverState *bs,
976 Qcow2ReopenState *r,
977 QDict *options, int flags,
978 Error **errp)
979{
980 BDRVQcow2State *s = bs->opaque;
981 QemuOpts *opts = NULL;
982 const char *opt_overlap_check, *opt_overlap_check_template;
983 int overlap_check_template = 0;
984 uint64_t l2_cache_size, l2_cache_entry_size, refcount_cache_size;
985 int i;
986 const char *encryptfmt;
987 QDict *encryptopts = NULL;
988 int ret;
989
990 qdict_extract_subqdict(options, &encryptopts, "encrypt.");
991 encryptfmt = qdict_get_try_str(encryptopts, "format");
992
993 opts = qemu_opts_create(&qcow2_runtime_opts, NULL, 0, &error_abort);
994 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
995 ret = -EINVAL;
996 goto fail;
997 }
998
999
1000 if (!read_cache_sizes(bs, opts, &l2_cache_size, &l2_cache_entry_size,
1001 &refcount_cache_size, errp)) {
1002 ret = -EINVAL;
1003 goto fail;
1004 }
1005
1006 l2_cache_size /= l2_cache_entry_size;
1007 if (l2_cache_size < MIN_L2_CACHE_SIZE) {
1008 l2_cache_size = MIN_L2_CACHE_SIZE;
1009 }
1010 if (l2_cache_size > INT_MAX) {
1011 error_setg(errp, "L2 cache size too big");
1012 ret = -EINVAL;
1013 goto fail;
1014 }
1015
1016 refcount_cache_size /= s->cluster_size;
1017 if (refcount_cache_size < MIN_REFCOUNT_CACHE_SIZE) {
1018 refcount_cache_size = MIN_REFCOUNT_CACHE_SIZE;
1019 }
1020 if (refcount_cache_size > INT_MAX) {
1021 error_setg(errp, "Refcount cache size too big");
1022 ret = -EINVAL;
1023 goto fail;
1024 }
1025
1026
1027 if (s->l2_table_cache) {
1028 ret = qcow2_cache_flush(bs, s->l2_table_cache);
1029 if (ret) {
1030 error_setg_errno(errp, -ret, "Failed to flush the L2 table cache");
1031 goto fail;
1032 }
1033 }
1034
1035 if (s->refcount_block_cache) {
1036 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
1037 if (ret) {
1038 error_setg_errno(errp, -ret,
1039 "Failed to flush the refcount block cache");
1040 goto fail;
1041 }
1042 }
1043
1044 r->l2_slice_size = l2_cache_entry_size / l2_entry_size(s);
1045 r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size,
1046 l2_cache_entry_size);
1047 r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size,
1048 s->cluster_size);
1049 if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) {
1050 error_setg(errp, "Could not allocate metadata caches");
1051 ret = -ENOMEM;
1052 goto fail;
1053 }
1054
1055
1056 r->cache_clean_interval =
1057 qemu_opt_get_number(opts, QCOW2_OPT_CACHE_CLEAN_INTERVAL,
1058 DEFAULT_CACHE_CLEAN_INTERVAL);
1059#ifndef CONFIG_LINUX
1060 if (r->cache_clean_interval != 0) {
1061 error_setg(errp, QCOW2_OPT_CACHE_CLEAN_INTERVAL
1062 " not supported on this host");
1063 ret = -EINVAL;
1064 goto fail;
1065 }
1066#endif
1067 if (r->cache_clean_interval > UINT_MAX) {
1068 error_setg(errp, "Cache clean interval too big");
1069 ret = -EINVAL;
1070 goto fail;
1071 }
1072
1073
1074 r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS,
1075 (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS));
1076 if (r->use_lazy_refcounts && s->qcow_version < 3) {
1077 error_setg(errp, "Lazy refcounts require a qcow2 image with at least "
1078 "qemu 1.1 compatibility level");
1079 ret = -EINVAL;
1080 goto fail;
1081 }
1082
1083 if (s->use_lazy_refcounts && !r->use_lazy_refcounts) {
1084 ret = qcow2_mark_clean(bs);
1085 if (ret < 0) {
1086 error_setg_errno(errp, -ret, "Failed to disable lazy refcounts");
1087 goto fail;
1088 }
1089 }
1090
1091
1092 opt_overlap_check = qemu_opt_get(opts, QCOW2_OPT_OVERLAP);
1093 opt_overlap_check_template = qemu_opt_get(opts, QCOW2_OPT_OVERLAP_TEMPLATE);
1094 if (opt_overlap_check_template && opt_overlap_check &&
1095 strcmp(opt_overlap_check_template, opt_overlap_check))
1096 {
1097 error_setg(errp, "Conflicting values for qcow2 options '"
1098 QCOW2_OPT_OVERLAP "' ('%s') and '" QCOW2_OPT_OVERLAP_TEMPLATE
1099 "' ('%s')", opt_overlap_check, opt_overlap_check_template);
1100 ret = -EINVAL;
1101 goto fail;
1102 }
1103 if (!opt_overlap_check) {
1104 opt_overlap_check = opt_overlap_check_template ?: "cached";
1105 }
1106
1107 if (!strcmp(opt_overlap_check, "none")) {
1108 overlap_check_template = 0;
1109 } else if (!strcmp(opt_overlap_check, "constant")) {
1110 overlap_check_template = QCOW2_OL_CONSTANT;
1111 } else if (!strcmp(opt_overlap_check, "cached")) {
1112 overlap_check_template = QCOW2_OL_CACHED;
1113 } else if (!strcmp(opt_overlap_check, "all")) {
1114 overlap_check_template = QCOW2_OL_ALL;
1115 } else {
1116 error_setg(errp, "Unsupported value '%s' for qcow2 option "
1117 "'overlap-check'. Allowed are any of the following: "
1118 "none, constant, cached, all", opt_overlap_check);
1119 ret = -EINVAL;
1120 goto fail;
1121 }
1122
1123 r->overlap_check = 0;
1124 for (i = 0; i < QCOW2_OL_MAX_BITNR; i++) {
1125
1126
1127 r->overlap_check |=
1128 qemu_opt_get_bool(opts, overlap_bool_option_names[i],
1129 overlap_check_template & (1 << i)) << i;
1130 }
1131
1132 r->discard_passthrough[QCOW2_DISCARD_NEVER] = false;
1133 r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true;
1134 r->discard_passthrough[QCOW2_DISCARD_REQUEST] =
1135 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_REQUEST,
1136 flags & BDRV_O_UNMAP);
1137 r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] =
1138 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_SNAPSHOT, true);
1139 r->discard_passthrough[QCOW2_DISCARD_OTHER] =
1140 qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_OTHER, false);
1141
1142 switch (s->crypt_method_header) {
1143 case QCOW_CRYPT_NONE:
1144 if (encryptfmt) {
1145 error_setg(errp, "No encryption in image header, but options "
1146 "specified format '%s'", encryptfmt);
1147 ret = -EINVAL;
1148 goto fail;
1149 }
1150 break;
1151
1152 case QCOW_CRYPT_AES:
1153 if (encryptfmt && !g_str_equal(encryptfmt, "aes")) {
1154 error_setg(errp,
1155 "Header reported 'aes' encryption format but "
1156 "options specify '%s'", encryptfmt);
1157 ret = -EINVAL;
1158 goto fail;
1159 }
1160 qdict_put_str(encryptopts, "format", "qcow");
1161 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1162 if (!r->crypto_opts) {
1163 ret = -EINVAL;
1164 goto fail;
1165 }
1166 break;
1167
1168 case QCOW_CRYPT_LUKS:
1169 if (encryptfmt && !g_str_equal(encryptfmt, "luks")) {
1170 error_setg(errp,
1171 "Header reported 'luks' encryption format but "
1172 "options specify '%s'", encryptfmt);
1173 ret = -EINVAL;
1174 goto fail;
1175 }
1176 qdict_put_str(encryptopts, "format", "luks");
1177 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp);
1178 if (!r->crypto_opts) {
1179 ret = -EINVAL;
1180 goto fail;
1181 }
1182 break;
1183
1184 default:
1185 error_setg(errp, "Unsupported encryption method %d",
1186 s->crypt_method_header);
1187 ret = -EINVAL;
1188 goto fail;
1189 }
1190
1191 ret = 0;
1192fail:
1193 qobject_unref(encryptopts);
1194 qemu_opts_del(opts);
1195 opts = NULL;
1196 return ret;
1197}
1198
1199static void qcow2_update_options_commit(BlockDriverState *bs,
1200 Qcow2ReopenState *r)
1201{
1202 BDRVQcow2State *s = bs->opaque;
1203 int i;
1204
1205 if (s->l2_table_cache) {
1206 qcow2_cache_destroy(s->l2_table_cache);
1207 }
1208 if (s->refcount_block_cache) {
1209 qcow2_cache_destroy(s->refcount_block_cache);
1210 }
1211 s->l2_table_cache = r->l2_table_cache;
1212 s->refcount_block_cache = r->refcount_block_cache;
1213 s->l2_slice_size = r->l2_slice_size;
1214
1215 s->overlap_check = r->overlap_check;
1216 s->use_lazy_refcounts = r->use_lazy_refcounts;
1217
1218 for (i = 0; i < QCOW2_DISCARD_MAX; i++) {
1219 s->discard_passthrough[i] = r->discard_passthrough[i];
1220 }
1221
1222 if (s->cache_clean_interval != r->cache_clean_interval) {
1223 cache_clean_timer_del(bs);
1224 s->cache_clean_interval = r->cache_clean_interval;
1225 cache_clean_timer_init(bs, bdrv_get_aio_context(bs));
1226 }
1227
1228 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1229 s->crypto_opts = r->crypto_opts;
1230}
1231
1232static void qcow2_update_options_abort(BlockDriverState *bs,
1233 Qcow2ReopenState *r)
1234{
1235 if (r->l2_table_cache) {
1236 qcow2_cache_destroy(r->l2_table_cache);
1237 }
1238 if (r->refcount_block_cache) {
1239 qcow2_cache_destroy(r->refcount_block_cache);
1240 }
1241 qapi_free_QCryptoBlockOpenOptions(r->crypto_opts);
1242}
1243
1244static int qcow2_update_options(BlockDriverState *bs, QDict *options,
1245 int flags, Error **errp)
1246{
1247 Qcow2ReopenState r = {};
1248 int ret;
1249
1250 ret = qcow2_update_options_prepare(bs, &r, options, flags, errp);
1251 if (ret >= 0) {
1252 qcow2_update_options_commit(bs, &r);
1253 } else {
1254 qcow2_update_options_abort(bs, &r);
1255 }
1256
1257 return ret;
1258}
1259
1260static int validate_compression_type(BDRVQcow2State *s, Error **errp)
1261{
1262 switch (s->compression_type) {
1263 case QCOW2_COMPRESSION_TYPE_ZLIB:
1264#ifdef CONFIG_ZSTD
1265 case QCOW2_COMPRESSION_TYPE_ZSTD:
1266#endif
1267 break;
1268
1269 default:
1270 error_setg(errp, "qcow2: unknown compression type: %u",
1271 s->compression_type);
1272 return -ENOTSUP;
1273 }
1274
1275
1276
1277
1278
1279 if (s->compression_type == QCOW2_COMPRESSION_TYPE_ZLIB) {
1280 if (s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION) {
1281 error_setg(errp, "qcow2: Compression type incompatible feature "
1282 "bit must not be set");
1283 return -EINVAL;
1284 }
1285 } else {
1286 if (!(s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION)) {
1287 error_setg(errp, "qcow2: Compression type incompatible feature "
1288 "bit must be set");
1289 return -EINVAL;
1290 }
1291 }
1292
1293 return 0;
1294}
1295
1296
1297static int coroutine_fn GRAPH_RDLOCK
1298qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
1299 bool open_data_file, Error **errp)
1300{
1301 ERRP_GUARD();
1302 BDRVQcow2State *s = bs->opaque;
1303 unsigned int len, i;
1304 int ret = 0;
1305 QCowHeader header;
1306 uint64_t ext_end;
1307 uint64_t l1_vm_state_index;
1308 bool update_header = false;
1309
1310 ret = bdrv_co_pread(bs->file, 0, sizeof(header), &header, 0);
1311 if (ret < 0) {
1312 error_setg_errno(errp, -ret, "Could not read qcow2 header");
1313 goto fail;
1314 }
1315 header.magic = be32_to_cpu(header.magic);
1316 header.version = be32_to_cpu(header.version);
1317 header.backing_file_offset = be64_to_cpu(header.backing_file_offset);
1318 header.backing_file_size = be32_to_cpu(header.backing_file_size);
1319 header.size = be64_to_cpu(header.size);
1320 header.cluster_bits = be32_to_cpu(header.cluster_bits);
1321 header.crypt_method = be32_to_cpu(header.crypt_method);
1322 header.l1_table_offset = be64_to_cpu(header.l1_table_offset);
1323 header.l1_size = be32_to_cpu(header.l1_size);
1324 header.refcount_table_offset = be64_to_cpu(header.refcount_table_offset);
1325 header.refcount_table_clusters =
1326 be32_to_cpu(header.refcount_table_clusters);
1327 header.snapshots_offset = be64_to_cpu(header.snapshots_offset);
1328 header.nb_snapshots = be32_to_cpu(header.nb_snapshots);
1329
1330 if (header.magic != QCOW_MAGIC) {
1331 error_setg(errp, "Image is not in qcow2 format");
1332 ret = -EINVAL;
1333 goto fail;
1334 }
1335 if (header.version < 2 || header.version > 3) {
1336 error_setg(errp, "Unsupported qcow2 version %" PRIu32, header.version);
1337 ret = -ENOTSUP;
1338 goto fail;
1339 }
1340
1341 s->qcow_version = header.version;
1342
1343
1344 if (header.cluster_bits < MIN_CLUSTER_BITS ||
1345 header.cluster_bits > MAX_CLUSTER_BITS) {
1346 error_setg(errp, "Unsupported cluster size: 2^%" PRIu32,
1347 header.cluster_bits);
1348 ret = -EINVAL;
1349 goto fail;
1350 }
1351
1352 s->cluster_bits = header.cluster_bits;
1353 s->cluster_size = 1 << s->cluster_bits;
1354
1355
1356 if (header.version == 2) {
1357 header.incompatible_features = 0;
1358 header.compatible_features = 0;
1359 header.autoclear_features = 0;
1360 header.refcount_order = 4;
1361 header.header_length = 72;
1362 } else {
1363 header.incompatible_features =
1364 be64_to_cpu(header.incompatible_features);
1365 header.compatible_features = be64_to_cpu(header.compatible_features);
1366 header.autoclear_features = be64_to_cpu(header.autoclear_features);
1367 header.refcount_order = be32_to_cpu(header.refcount_order);
1368 header.header_length = be32_to_cpu(header.header_length);
1369
1370 if (header.header_length < 104) {
1371 error_setg(errp, "qcow2 header too short");
1372 ret = -EINVAL;
1373 goto fail;
1374 }
1375 }
1376
1377 if (header.header_length > s->cluster_size) {
1378 error_setg(errp, "qcow2 header exceeds cluster size");
1379 ret = -EINVAL;
1380 goto fail;
1381 }
1382
1383 if (header.header_length > sizeof(header)) {
1384 s->unknown_header_fields_size = header.header_length - sizeof(header);
1385 s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
1386 ret = bdrv_co_pread(bs->file, sizeof(header),
1387 s->unknown_header_fields_size,
1388 s->unknown_header_fields, 0);
1389 if (ret < 0) {
1390 error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
1391 "fields");
1392 goto fail;
1393 }
1394 }
1395
1396 if (header.backing_file_offset > s->cluster_size) {
1397 error_setg(errp, "Invalid backing file offset");
1398 ret = -EINVAL;
1399 goto fail;
1400 }
1401
1402 if (header.backing_file_offset) {
1403 ext_end = header.backing_file_offset;
1404 } else {
1405 ext_end = 1 << header.cluster_bits;
1406 }
1407
1408
1409 s->incompatible_features = header.incompatible_features;
1410 s->compatible_features = header.compatible_features;
1411 s->autoclear_features = header.autoclear_features;
1412
1413
1414
1415
1416
1417
1418
1419 if (header.header_length > offsetof(QCowHeader, compression_type)) {
1420 s->compression_type = header.compression_type;
1421 } else {
1422 s->compression_type = QCOW2_COMPRESSION_TYPE_ZLIB;
1423 }
1424
1425 ret = validate_compression_type(s, errp);
1426 if (ret) {
1427 goto fail;
1428 }
1429
1430 if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) {
1431 void *feature_table = NULL;
1432 qcow2_read_extensions(bs, header.header_length, ext_end,
1433 &feature_table, flags, NULL, NULL);
1434 report_unsupported_feature(errp, feature_table,
1435 s->incompatible_features &
1436 ~QCOW2_INCOMPAT_MASK);
1437 ret = -ENOTSUP;
1438 g_free(feature_table);
1439 goto fail;
1440 }
1441
1442 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) {
1443
1444
1445 if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_CHECK)) {
1446 error_setg(errp, "qcow2: Image is corrupt; cannot be opened "
1447 "read/write");
1448 ret = -EACCES;
1449 goto fail;
1450 }
1451 }
1452
1453 s->subclusters_per_cluster =
1454 has_subclusters(s) ? QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER : 1;
1455 s->subcluster_size = s->cluster_size / s->subclusters_per_cluster;
1456 s->subcluster_bits = ctz32(s->subcluster_size);
1457
1458 if (s->subcluster_size < (1 << MIN_CLUSTER_BITS)) {
1459 error_setg(errp, "Unsupported subcluster size: %d", s->subcluster_size);
1460 ret = -EINVAL;
1461 goto fail;
1462 }
1463
1464
1465 if (header.refcount_order > 6) {
1466 error_setg(errp, "Reference count entry width too large; may not "
1467 "exceed 64 bits");
1468 ret = -EINVAL;
1469 goto fail;
1470 }
1471 s->refcount_order = header.refcount_order;
1472 s->refcount_bits = 1 << s->refcount_order;
1473 s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
1474 s->refcount_max += s->refcount_max - 1;
1475
1476 s->crypt_method_header = header.crypt_method;
1477 if (s->crypt_method_header) {
1478 if (bdrv_uses_whitelist() &&
1479 s->crypt_method_header == QCOW_CRYPT_AES) {
1480 error_setg(errp,
1481 "Use of AES-CBC encrypted qcow2 images is no longer "
1482 "supported in system emulators");
1483 error_append_hint(errp,
1484 "You can use 'qemu-img convert' to convert your "
1485 "image to an alternative supported format, such "
1486 "as unencrypted qcow2, or raw with the LUKS "
1487 "format instead.\n");
1488 ret = -ENOSYS;
1489 goto fail;
1490 }
1491
1492 if (s->crypt_method_header == QCOW_CRYPT_AES) {
1493 s->crypt_physical_offset = false;
1494 } else {
1495
1496
1497
1498 s->crypt_physical_offset = true;
1499 }
1500
1501 bs->encrypted = true;
1502 }
1503
1504 s->l2_bits = s->cluster_bits - ctz32(l2_entry_size(s));
1505 s->l2_size = 1 << s->l2_bits;
1506
1507 s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3);
1508 s->refcount_block_size = 1 << s->refcount_block_bits;
1509 bs->total_sectors = header.size / BDRV_SECTOR_SIZE;
1510 s->csize_shift = (62 - (s->cluster_bits - 8));
1511 s->csize_mask = (1 << (s->cluster_bits - 8)) - 1;
1512 s->cluster_offset_mask = (1LL << s->csize_shift) - 1;
1513
1514 s->refcount_table_offset = header.refcount_table_offset;
1515 s->refcount_table_size =
1516 header.refcount_table_clusters << (s->cluster_bits - 3);
1517
1518 if (header.refcount_table_clusters == 0 && !(flags & BDRV_O_CHECK)) {
1519 error_setg(errp, "Image does not contain a reference count table");
1520 ret = -EINVAL;
1521 goto fail;
1522 }
1523
1524 ret = qcow2_validate_table(bs, s->refcount_table_offset,
1525 header.refcount_table_clusters,
1526 s->cluster_size, QCOW_MAX_REFTABLE_SIZE,
1527 "Reference count table", errp);
1528 if (ret < 0) {
1529 goto fail;
1530 }
1531
1532 if (!(flags & BDRV_O_CHECK)) {
1533
1534
1535
1536
1537
1538
1539 ret = qcow2_validate_table(bs, header.snapshots_offset,
1540 header.nb_snapshots,
1541 sizeof(QCowSnapshotHeader),
1542 sizeof(QCowSnapshotHeader) *
1543 QCOW_MAX_SNAPSHOTS,
1544 "Snapshot table", errp);
1545 if (ret < 0) {
1546 goto fail;
1547 }
1548 }
1549
1550
1551 ret = qcow2_validate_table(bs, header.l1_table_offset,
1552 header.l1_size, L1E_SIZE,
1553 QCOW_MAX_L1_SIZE, "Active L1 table", errp);
1554 if (ret < 0) {
1555 goto fail;
1556 }
1557 s->l1_size = header.l1_size;
1558 s->l1_table_offset = header.l1_table_offset;
1559
1560 l1_vm_state_index = size_to_l1(s, header.size);
1561 if (l1_vm_state_index > INT_MAX) {
1562 error_setg(errp, "Image is too big");
1563 ret = -EFBIG;
1564 goto fail;
1565 }
1566 s->l1_vm_state_index = l1_vm_state_index;
1567
1568
1569
1570 if (s->l1_size < s->l1_vm_state_index) {
1571 error_setg(errp, "L1 table is too small");
1572 ret = -EINVAL;
1573 goto fail;
1574 }
1575
1576 if (s->l1_size > 0) {
1577 s->l1_table = qemu_try_blockalign(bs->file->bs, s->l1_size * L1E_SIZE);
1578 if (s->l1_table == NULL) {
1579 error_setg(errp, "Could not allocate L1 table");
1580 ret = -ENOMEM;
1581 goto fail;
1582 }
1583 ret = bdrv_co_pread(bs->file, s->l1_table_offset, s->l1_size * L1E_SIZE,
1584 s->l1_table, 0);
1585 if (ret < 0) {
1586 error_setg_errno(errp, -ret, "Could not read L1 table");
1587 goto fail;
1588 }
1589 for(i = 0;i < s->l1_size; i++) {
1590 s->l1_table[i] = be64_to_cpu(s->l1_table[i]);
1591 }
1592 }
1593
1594
1595 ret = qcow2_update_options(bs, options, flags, errp);
1596 if (ret < 0) {
1597 goto fail;
1598 }
1599
1600 s->flags = flags;
1601
1602 ret = qcow2_refcount_init(bs);
1603 if (ret != 0) {
1604 error_setg_errno(errp, -ret, "Could not initialize refcount handling");
1605 goto fail;
1606 }
1607
1608 QLIST_INIT(&s->cluster_allocs);
1609 QTAILQ_INIT(&s->discards);
1610
1611
1612 if (qcow2_read_extensions(bs, header.header_length, ext_end, NULL,
1613 flags, &update_header, errp)) {
1614 ret = -EINVAL;
1615 goto fail;
1616 }
1617
1618 if (open_data_file) {
1619
1620 s->data_file = bdrv_co_open_child(NULL, options, "data-file", bs,
1621 &child_of_bds, BDRV_CHILD_DATA,
1622 true, errp);
1623 if (*errp) {
1624 ret = -EINVAL;
1625 goto fail;
1626 }
1627
1628 if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
1629 if (!s->data_file && s->image_data_file) {
1630 s->data_file = bdrv_co_open_child(s->image_data_file, options,
1631 "data-file", bs,
1632 &child_of_bds,
1633 BDRV_CHILD_DATA, false, errp);
1634 if (!s->data_file) {
1635 ret = -EINVAL;
1636 goto fail;
1637 }
1638 }
1639 if (!s->data_file) {
1640 error_setg(errp, "'data-file' is required for this image");
1641 ret = -EINVAL;
1642 goto fail;
1643 }
1644
1645
1646 bs->file->role &= ~BDRV_CHILD_DATA;
1647
1648
1649 bdrv_child_refresh_perms(bs, bs->file, &error_abort);
1650 } else {
1651 if (s->data_file) {
1652 error_setg(errp, "'data-file' can only be set for images with "
1653 "an external data file");
1654 ret = -EINVAL;
1655 goto fail;
1656 }
1657
1658 s->data_file = bs->file;
1659
1660 if (data_file_is_raw(bs)) {
1661 error_setg(errp, "data-file-raw requires a data file");
1662 ret = -EINVAL;
1663 goto fail;
1664 }
1665 }
1666 }
1667
1668
1669
1670
1671
1672 if (s->crypt_method_header && !s->crypto) {
1673 if (s->crypt_method_header == QCOW_CRYPT_AES) {
1674 unsigned int cflags = 0;
1675 if (flags & BDRV_O_NO_IO) {
1676 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
1677 }
1678 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.",
1679 NULL, NULL, cflags,
1680 QCOW2_MAX_THREADS, errp);
1681 if (!s->crypto) {
1682 ret = -EINVAL;
1683 goto fail;
1684 }
1685 } else if (!(flags & BDRV_O_NO_IO)) {
1686 error_setg(errp, "Missing CRYPTO header for crypt method %d",
1687 s->crypt_method_header);
1688 ret = -EINVAL;
1689 goto fail;
1690 }
1691 }
1692
1693
1694 if (header.backing_file_offset != 0) {
1695 len = header.backing_file_size;
1696 if (len > MIN(1023, s->cluster_size - header.backing_file_offset) ||
1697 len >= sizeof(bs->backing_file)) {
1698 error_setg(errp, "Backing file name too long");
1699 ret = -EINVAL;
1700 goto fail;
1701 }
1702
1703 s->image_backing_file = g_malloc(len + 1);
1704 ret = bdrv_co_pread(bs->file, header.backing_file_offset, len,
1705 s->image_backing_file, 0);
1706 if (ret < 0) {
1707 error_setg_errno(errp, -ret, "Could not read backing file name");
1708 goto fail;
1709 }
1710 s->image_backing_file[len] = '\0';
1711
1712
1713
1714
1715
1716
1717 if (!g_str_equal(s->image_backing_file, bs->backing_file)) {
1718 pstrcpy(bs->backing_file, sizeof(bs->backing_file),
1719 s->image_backing_file);
1720 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
1721 s->image_backing_file);
1722 }
1723 }
1724
1725
1726
1727
1728
1729
1730 if (!(flags & BDRV_O_CHECK)) {
1731 s->snapshots_offset = header.snapshots_offset;
1732 s->nb_snapshots = header.nb_snapshots;
1733
1734 ret = qcow2_read_snapshots(bs, errp);
1735 if (ret < 0) {
1736 goto fail;
1737 }
1738 }
1739
1740
1741 update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK;
1742 update_header = update_header && bdrv_is_writable(bs);
1743 if (update_header) {
1744 s->autoclear_features &= QCOW2_AUTOCLEAR_MASK;
1745 }
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805 if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) {
1806
1807 bool header_updated;
1808 if (!qcow2_load_dirty_bitmaps(bs, &header_updated, errp)) {
1809 ret = -EINVAL;
1810 goto fail;
1811 }
1812
1813 update_header = update_header && !header_updated;
1814 }
1815
1816 if (update_header) {
1817 ret = qcow2_update_header(bs);
1818 if (ret < 0) {
1819 error_setg_errno(errp, -ret, "Could not update qcow2 header");
1820 goto fail;
1821 }
1822 }
1823
1824 bs->supported_zero_flags = header.version >= 3 ?
1825 BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
1826 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
1827
1828
1829 if (!(flags & BDRV_O_CHECK) && bdrv_is_writable(bs) &&
1830 (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) {
1831 BdrvCheckResult result = {0};
1832
1833 ret = qcow2_co_check_locked(bs, &result,
1834 BDRV_FIX_ERRORS | BDRV_FIX_LEAKS);
1835 if (ret < 0 || result.check_errors) {
1836 if (ret >= 0) {
1837 ret = -EIO;
1838 }
1839 error_setg_errno(errp, -ret, "Could not repair dirty image");
1840 goto fail;
1841 }
1842 }
1843
1844#ifdef DEBUG_ALLOC
1845 {
1846 BdrvCheckResult result = {0};
1847 qcow2_check_refcounts(bs, &result, 0);
1848 }
1849#endif
1850
1851 qemu_co_queue_init(&s->thread_task_queue);
1852
1853 return ret;
1854
1855 fail:
1856 g_free(s->image_data_file);
1857 if (open_data_file && has_data_file(bs)) {
1858 bdrv_unref_child(bs, s->data_file);
1859 s->data_file = NULL;
1860 }
1861 g_free(s->unknown_header_fields);
1862 cleanup_unknown_header_ext(bs);
1863 qcow2_free_snapshots(bs);
1864 qcow2_refcount_close(bs);
1865 qemu_vfree(s->l1_table);
1866
1867 s->l1_table = NULL;
1868 cache_clean_timer_del(bs);
1869 if (s->l2_table_cache) {
1870 qcow2_cache_destroy(s->l2_table_cache);
1871 }
1872 if (s->refcount_block_cache) {
1873 qcow2_cache_destroy(s->refcount_block_cache);
1874 }
1875 qcrypto_block_free(s->crypto);
1876 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
1877 return ret;
1878}
1879
1880typedef struct QCow2OpenCo {
1881 BlockDriverState *bs;
1882 QDict *options;
1883 int flags;
1884 Error **errp;
1885 int ret;
1886} QCow2OpenCo;
1887
1888static void coroutine_fn qcow2_open_entry(void *opaque)
1889{
1890 QCow2OpenCo *qoc = opaque;
1891 BDRVQcow2State *s = qoc->bs->opaque;
1892
1893 assume_graph_lock();
1894
1895 qemu_co_mutex_lock(&s->lock);
1896 qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, true,
1897 qoc->errp);
1898 qemu_co_mutex_unlock(&s->lock);
1899}
1900
1901static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
1902 Error **errp)
1903{
1904 BDRVQcow2State *s = bs->opaque;
1905 QCow2OpenCo qoc = {
1906 .bs = bs,
1907 .options = options,
1908 .flags = flags,
1909 .errp = errp,
1910 .ret = -EINPROGRESS
1911 };
1912 int ret;
1913
1914 ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
1915 if (ret < 0) {
1916 return ret;
1917 }
1918
1919
1920 qemu_co_mutex_init(&s->lock);
1921
1922 if (qemu_in_coroutine()) {
1923
1924 qcow2_open_entry(&qoc);
1925 } else {
1926 assert(qemu_get_current_aio_context() == qemu_get_aio_context());
1927 qemu_coroutine_enter(qemu_coroutine_create(qcow2_open_entry, &qoc));
1928 BDRV_POLL_WHILE(bs, qoc.ret == -EINPROGRESS);
1929 }
1930 return qoc.ret;
1931}
1932
1933static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
1934{
1935 BDRVQcow2State *s = bs->opaque;
1936
1937 if (bs->encrypted) {
1938
1939 bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto);
1940 }
1941 bs->bl.pwrite_zeroes_alignment = s->subcluster_size;
1942 bs->bl.pdiscard_alignment = s->cluster_size;
1943}
1944
1945static int qcow2_reopen_prepare(BDRVReopenState *state,
1946 BlockReopenQueue *queue, Error **errp)
1947{
1948 BDRVQcow2State *s = state->bs->opaque;
1949 Qcow2ReopenState *r;
1950 int ret;
1951
1952 r = g_new0(Qcow2ReopenState, 1);
1953 state->opaque = r;
1954
1955 ret = qcow2_update_options_prepare(state->bs, r, state->options,
1956 state->flags, errp);
1957 if (ret < 0) {
1958 goto fail;
1959 }
1960
1961
1962 if ((state->flags & BDRV_O_RDWR) == 0) {
1963 ret = qcow2_reopen_bitmaps_ro(state->bs, errp);
1964 if (ret < 0) {
1965 goto fail;
1966 }
1967
1968 ret = bdrv_flush(state->bs);
1969 if (ret < 0) {
1970 goto fail;
1971 }
1972
1973 ret = qcow2_mark_clean(state->bs);
1974 if (ret < 0) {
1975 goto fail;
1976 }
1977 }
1978
1979
1980
1981
1982
1983
1984 if (!has_data_file(state->bs)) {
1985 assert(s->data_file == state->bs->file);
1986 s->data_file = NULL;
1987 }
1988
1989 return 0;
1990
1991fail:
1992 qcow2_update_options_abort(state->bs, r);
1993 g_free(r);
1994 return ret;
1995}
1996
1997static void qcow2_reopen_commit(BDRVReopenState *state)
1998{
1999 BDRVQcow2State *s = state->bs->opaque;
2000
2001 qcow2_update_options_commit(state->bs, state->opaque);
2002 if (!s->data_file) {
2003
2004
2005
2006
2007 s->data_file = state->bs->file;
2008 }
2009 g_free(state->opaque);
2010}
2011
2012static void qcow2_reopen_commit_post(BDRVReopenState *state)
2013{
2014 if (state->flags & BDRV_O_RDWR) {
2015 Error *local_err = NULL;
2016
2017 if (qcow2_reopen_bitmaps_rw(state->bs, &local_err) < 0) {
2018
2019
2020
2021
2022
2023 error_reportf_err(local_err,
2024 "%s: Failed to make dirty bitmaps writable: ",
2025 bdrv_get_node_name(state->bs));
2026 }
2027 }
2028}
2029
2030static void qcow2_reopen_abort(BDRVReopenState *state)
2031{
2032 BDRVQcow2State *s = state->bs->opaque;
2033
2034 if (!s->data_file) {
2035
2036
2037
2038
2039 s->data_file = state->bs->file;
2040 }
2041 qcow2_update_options_abort(state->bs, state->opaque);
2042 g_free(state->opaque);
2043}
2044
2045static void qcow2_join_options(QDict *options, QDict *old_options)
2046{
2047 bool has_new_overlap_template =
2048 qdict_haskey(options, QCOW2_OPT_OVERLAP) ||
2049 qdict_haskey(options, QCOW2_OPT_OVERLAP_TEMPLATE);
2050 bool has_new_total_cache_size =
2051 qdict_haskey(options, QCOW2_OPT_CACHE_SIZE);
2052 bool has_all_cache_options;
2053
2054
2055 if (has_new_overlap_template) {
2056 qdict_del(old_options, QCOW2_OPT_OVERLAP);
2057 qdict_del(old_options, QCOW2_OPT_OVERLAP_TEMPLATE);
2058 qdict_del(old_options, QCOW2_OPT_OVERLAP_MAIN_HEADER);
2059 qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L1);
2060 qdict_del(old_options, QCOW2_OPT_OVERLAP_ACTIVE_L2);
2061 qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_TABLE);
2062 qdict_del(old_options, QCOW2_OPT_OVERLAP_REFCOUNT_BLOCK);
2063 qdict_del(old_options, QCOW2_OPT_OVERLAP_SNAPSHOT_TABLE);
2064 qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L1);
2065 qdict_del(old_options, QCOW2_OPT_OVERLAP_INACTIVE_L2);
2066 }
2067
2068
2069 if (qdict_haskey(options, QCOW2_OPT_CACHE_SIZE)) {
2070 qdict_del(old_options, QCOW2_OPT_L2_CACHE_SIZE);
2071 qdict_del(old_options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
2072 }
2073
2074 qdict_join(options, old_options, false);
2075
2076
2077
2078
2079
2080
2081 has_all_cache_options =
2082 qdict_haskey(options, QCOW2_OPT_CACHE_SIZE) ||
2083 qdict_haskey(options, QCOW2_OPT_L2_CACHE_SIZE) ||
2084 qdict_haskey(options, QCOW2_OPT_REFCOUNT_CACHE_SIZE);
2085
2086 if (has_all_cache_options && !has_new_total_cache_size) {
2087 qdict_del(options, QCOW2_OPT_CACHE_SIZE);
2088 }
2089}
2090
2091static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
2092 bool want_zero,
2093 int64_t offset, int64_t count,
2094 int64_t *pnum, int64_t *map,
2095 BlockDriverState **file)
2096{
2097 BDRVQcow2State *s = bs->opaque;
2098 uint64_t host_offset;
2099 unsigned int bytes;
2100 QCow2SubclusterType type;
2101 int ret, status = 0;
2102
2103 qemu_co_mutex_lock(&s->lock);
2104
2105 if (!s->metadata_preallocation_checked) {
2106 ret = qcow2_detect_metadata_preallocation(bs);
2107 s->metadata_preallocation = (ret == 1);
2108 s->metadata_preallocation_checked = true;
2109 }
2110
2111 bytes = MIN(INT_MAX, count);
2112 ret = qcow2_get_host_offset(bs, offset, &bytes, &host_offset, &type);
2113 qemu_co_mutex_unlock(&s->lock);
2114 if (ret < 0) {
2115 return ret;
2116 }
2117
2118 *pnum = bytes;
2119
2120 if ((type == QCOW2_SUBCLUSTER_NORMAL ||
2121 type == QCOW2_SUBCLUSTER_ZERO_ALLOC ||
2122 type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC) && !s->crypto) {
2123 *map = host_offset;
2124 *file = s->data_file->bs;
2125 status |= BDRV_BLOCK_OFFSET_VALID;
2126 }
2127 if (type == QCOW2_SUBCLUSTER_ZERO_PLAIN ||
2128 type == QCOW2_SUBCLUSTER_ZERO_ALLOC) {
2129 status |= BDRV_BLOCK_ZERO;
2130 } else if (type != QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN &&
2131 type != QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC) {
2132 status |= BDRV_BLOCK_DATA;
2133 }
2134 if (s->metadata_preallocation && (status & BDRV_BLOCK_DATA) &&
2135 (status & BDRV_BLOCK_OFFSET_VALID))
2136 {
2137 status |= BDRV_BLOCK_RECURSE;
2138 }
2139 return status;
2140}
2141
2142static int coroutine_fn GRAPH_RDLOCK
2143qcow2_handle_l2meta(BlockDriverState *bs, QCowL2Meta **pl2meta, bool link_l2)
2144{
2145 int ret = 0;
2146 QCowL2Meta *l2meta = *pl2meta;
2147
2148 while (l2meta != NULL) {
2149 QCowL2Meta *next;
2150
2151 if (link_l2) {
2152 ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
2153 if (ret) {
2154 goto out;
2155 }
2156 } else {
2157 qcow2_alloc_cluster_abort(bs, l2meta);
2158 }
2159
2160
2161 QLIST_REMOVE(l2meta, next_in_flight);
2162
2163 qemu_co_queue_restart_all(&l2meta->dependent_requests);
2164
2165 next = l2meta->next;
2166 g_free(l2meta);
2167 l2meta = next;
2168 }
2169out:
2170 *pl2meta = l2meta;
2171 return ret;
2172}
2173
2174static int coroutine_fn GRAPH_RDLOCK
2175qcow2_co_preadv_encrypted(BlockDriverState *bs,
2176 uint64_t host_offset,
2177 uint64_t offset,
2178 uint64_t bytes,
2179 QEMUIOVector *qiov,
2180 uint64_t qiov_offset)
2181{
2182 int ret;
2183 BDRVQcow2State *s = bs->opaque;
2184 uint8_t *buf;
2185
2186 assert(bs->encrypted && s->crypto);
2187 assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197 buf = qemu_try_blockalign(s->data_file->bs, bytes);
2198 if (buf == NULL) {
2199 return -ENOMEM;
2200 }
2201
2202 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
2203 ret = bdrv_co_pread(s->data_file, host_offset, bytes, buf, 0);
2204 if (ret < 0) {
2205 goto fail;
2206 }
2207
2208 if (qcow2_co_decrypt(bs, host_offset, offset, buf, bytes) < 0)
2209 {
2210 ret = -EIO;
2211 goto fail;
2212 }
2213 qemu_iovec_from_buf(qiov, qiov_offset, buf, bytes);
2214
2215fail:
2216 qemu_vfree(buf);
2217
2218 return ret;
2219}
2220
2221typedef struct Qcow2AioTask {
2222 AioTask task;
2223
2224 BlockDriverState *bs;
2225 QCow2SubclusterType subcluster_type;
2226 uint64_t host_offset;
2227 uint64_t offset;
2228 uint64_t bytes;
2229 QEMUIOVector *qiov;
2230 uint64_t qiov_offset;
2231 QCowL2Meta *l2meta;
2232} Qcow2AioTask;
2233
2234static coroutine_fn int qcow2_co_preadv_task_entry(AioTask *task);
2235static coroutine_fn int qcow2_add_task(BlockDriverState *bs,
2236 AioTaskPool *pool,
2237 AioTaskFunc func,
2238 QCow2SubclusterType subcluster_type,
2239 uint64_t host_offset,
2240 uint64_t offset,
2241 uint64_t bytes,
2242 QEMUIOVector *qiov,
2243 size_t qiov_offset,
2244 QCowL2Meta *l2meta)
2245{
2246 Qcow2AioTask local_task;
2247 Qcow2AioTask *task = pool ? g_new(Qcow2AioTask, 1) : &local_task;
2248
2249 *task = (Qcow2AioTask) {
2250 .task.func = func,
2251 .bs = bs,
2252 .subcluster_type = subcluster_type,
2253 .qiov = qiov,
2254 .host_offset = host_offset,
2255 .offset = offset,
2256 .bytes = bytes,
2257 .qiov_offset = qiov_offset,
2258 .l2meta = l2meta,
2259 };
2260
2261 trace_qcow2_add_task(qemu_coroutine_self(), bs, pool,
2262 func == qcow2_co_preadv_task_entry ? "read" : "write",
2263 subcluster_type, host_offset, offset, bytes,
2264 qiov, qiov_offset);
2265
2266 if (!pool) {
2267 return func(&task->task);
2268 }
2269
2270 aio_task_pool_start_task(pool, &task->task);
2271
2272 return 0;
2273}
2274
2275static int coroutine_fn GRAPH_RDLOCK
2276qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,
2277 uint64_t host_offset, uint64_t offset, uint64_t bytes,
2278 QEMUIOVector *qiov, size_t qiov_offset)
2279{
2280 BDRVQcow2State *s = bs->opaque;
2281
2282 switch (subc_type) {
2283 case QCOW2_SUBCLUSTER_ZERO_PLAIN:
2284 case QCOW2_SUBCLUSTER_ZERO_ALLOC:
2285
2286 g_assert_not_reached();
2287
2288 case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
2289 case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
2290 assert(bs->backing);
2291
2292 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
2293 return bdrv_co_preadv_part(bs->backing, offset, bytes,
2294 qiov, qiov_offset, 0);
2295
2296 case QCOW2_SUBCLUSTER_COMPRESSED:
2297 return qcow2_co_preadv_compressed(bs, host_offset,
2298 offset, bytes, qiov, qiov_offset);
2299
2300 case QCOW2_SUBCLUSTER_NORMAL:
2301 if (bs->encrypted) {
2302 return qcow2_co_preadv_encrypted(bs, host_offset,
2303 offset, bytes, qiov, qiov_offset);
2304 }
2305
2306 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
2307 return bdrv_co_preadv_part(s->data_file, host_offset,
2308 bytes, qiov, qiov_offset, 0);
2309
2310 default:
2311 g_assert_not_reached();
2312 }
2313
2314 g_assert_not_reached();
2315}
2316
2317
2318
2319
2320
2321static int coroutine_fn GRAPH_RDLOCK qcow2_co_preadv_task_entry(AioTask *task)
2322{
2323 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
2324
2325 assert(!t->l2meta);
2326
2327 return qcow2_co_preadv_task(t->bs, t->subcluster_type,
2328 t->host_offset, t->offset, t->bytes,
2329 t->qiov, t->qiov_offset);
2330}
2331
2332static int coroutine_fn GRAPH_RDLOCK
2333qcow2_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
2334 QEMUIOVector *qiov, size_t qiov_offset,
2335 BdrvRequestFlags flags)
2336{
2337 BDRVQcow2State *s = bs->opaque;
2338 int ret = 0;
2339 unsigned int cur_bytes;
2340 uint64_t host_offset = 0;
2341 QCow2SubclusterType type;
2342 AioTaskPool *aio = NULL;
2343
2344 while (bytes != 0 && aio_task_pool_status(aio) == 0) {
2345
2346 cur_bytes = MIN(bytes, INT_MAX);
2347 if (s->crypto) {
2348 cur_bytes = MIN(cur_bytes,
2349 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2350 }
2351
2352 qemu_co_mutex_lock(&s->lock);
2353 ret = qcow2_get_host_offset(bs, offset, &cur_bytes,
2354 &host_offset, &type);
2355 qemu_co_mutex_unlock(&s->lock);
2356 if (ret < 0) {
2357 goto out;
2358 }
2359
2360 if (type == QCOW2_SUBCLUSTER_ZERO_PLAIN ||
2361 type == QCOW2_SUBCLUSTER_ZERO_ALLOC ||
2362 (type == QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && !bs->backing) ||
2363 (type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC && !bs->backing))
2364 {
2365 qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes);
2366 } else {
2367 if (!aio && cur_bytes != bytes) {
2368 aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
2369 }
2370 ret = qcow2_add_task(bs, aio, qcow2_co_preadv_task_entry, type,
2371 host_offset, offset, cur_bytes,
2372 qiov, qiov_offset, NULL);
2373 if (ret < 0) {
2374 goto out;
2375 }
2376 }
2377
2378 bytes -= cur_bytes;
2379 offset += cur_bytes;
2380 qiov_offset += cur_bytes;
2381 }
2382
2383out:
2384 if (aio) {
2385 aio_task_pool_wait_all(aio);
2386 if (ret == 0) {
2387 ret = aio_task_pool_status(aio);
2388 }
2389 g_free(aio);
2390 }
2391
2392 return ret;
2393}
2394
2395
2396
2397static bool merge_cow(uint64_t offset, unsigned bytes,
2398 QEMUIOVector *qiov, size_t qiov_offset,
2399 QCowL2Meta *l2meta)
2400{
2401 QCowL2Meta *m;
2402
2403 for (m = l2meta; m != NULL; m = m->next) {
2404
2405 if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) {
2406 continue;
2407 }
2408
2409
2410 if (m->skip_cow) {
2411 continue;
2412 }
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422 if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) {
2423
2424 assert(offset < l2meta_cow_start(m));
2425 assert(m->cow_start.nb_bytes == 0);
2426 continue;
2427 }
2428
2429
2430
2431 if (m->offset + m->cow_end.offset != offset + bytes) {
2432 assert(offset + bytes > m->offset + m->cow_end.offset);
2433 assert(m->cow_end.nb_bytes == 0);
2434 continue;
2435 }
2436
2437
2438
2439 if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) {
2440 continue;
2441 }
2442
2443 m->data_qiov = qiov;
2444 m->data_qiov_offset = qiov_offset;
2445 return true;
2446 }
2447
2448 return false;
2449}
2450
2451
2452
2453
2454
2455static int coroutine_fn GRAPH_RDLOCK
2456is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)
2457{
2458
2459
2460
2461
2462
2463
2464 int ret = bdrv_co_is_zero_fast(bs, m->offset + m->cow_start.offset,
2465 m->cow_start.nb_bytes);
2466 if (ret <= 0) {
2467 return ret;
2468 }
2469
2470 return bdrv_co_is_zero_fast(bs, m->offset + m->cow_end.offset,
2471 m->cow_end.nb_bytes);
2472}
2473
2474static int coroutine_fn GRAPH_RDLOCK
2475handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
2476{
2477 BDRVQcow2State *s = bs->opaque;
2478 QCowL2Meta *m;
2479
2480 if (!(s->data_file->bs->supported_zero_flags & BDRV_REQ_NO_FALLBACK)) {
2481 return 0;
2482 }
2483
2484 if (bs->encrypted) {
2485 return 0;
2486 }
2487
2488 for (m = l2meta; m != NULL; m = m->next) {
2489 int ret;
2490 uint64_t start_offset = m->alloc_offset + m->cow_start.offset;
2491 unsigned nb_bytes = m->cow_end.offset + m->cow_end.nb_bytes -
2492 m->cow_start.offset;
2493
2494 if (!m->cow_start.nb_bytes && !m->cow_end.nb_bytes) {
2495 continue;
2496 }
2497
2498 ret = is_zero_cow(bs, m);
2499 if (ret < 0) {
2500 return ret;
2501 } else if (ret == 0) {
2502 continue;
2503 }
2504
2505
2506
2507
2508
2509
2510 ret = qcow2_pre_write_overlap_check(bs, 0, start_offset, nb_bytes,
2511 true);
2512 if (ret < 0) {
2513 return ret;
2514 }
2515
2516 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
2517 ret = bdrv_co_pwrite_zeroes(s->data_file, start_offset, nb_bytes,
2518 BDRV_REQ_NO_FALLBACK);
2519 if (ret < 0) {
2520 if (ret != -ENOTSUP && ret != -EAGAIN) {
2521 return ret;
2522 }
2523 continue;
2524 }
2525
2526 trace_qcow2_skip_cow(qemu_coroutine_self(), m->offset, m->nb_clusters);
2527 m->skip_cow = true;
2528 }
2529 return 0;
2530}
2531
2532
2533
2534
2535
2536
2537
2538static coroutine_fn GRAPH_RDLOCK
2539int qcow2_co_pwritev_task(BlockDriverState *bs, uint64_t host_offset,
2540 uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
2541 uint64_t qiov_offset, QCowL2Meta *l2meta)
2542{
2543 int ret;
2544 BDRVQcow2State *s = bs->opaque;
2545 void *crypt_buf = NULL;
2546 QEMUIOVector encrypted_qiov;
2547
2548 if (bs->encrypted) {
2549 assert(s->crypto);
2550 assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2551 crypt_buf = qemu_try_blockalign(bs->file->bs, bytes);
2552 if (crypt_buf == NULL) {
2553 ret = -ENOMEM;
2554 goto out_unlocked;
2555 }
2556 qemu_iovec_to_buf(qiov, qiov_offset, crypt_buf, bytes);
2557
2558 if (qcow2_co_encrypt(bs, host_offset, offset, crypt_buf, bytes) < 0) {
2559 ret = -EIO;
2560 goto out_unlocked;
2561 }
2562
2563 qemu_iovec_init_buf(&encrypted_qiov, crypt_buf, bytes);
2564 qiov = &encrypted_qiov;
2565 qiov_offset = 0;
2566 }
2567
2568
2569 ret = handle_alloc_space(bs, l2meta);
2570 if (ret < 0) {
2571 goto out_unlocked;
2572 }
2573
2574
2575
2576
2577
2578
2579
2580 if (!merge_cow(offset, bytes, qiov, qiov_offset, l2meta)) {
2581 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
2582 trace_qcow2_writev_data(qemu_coroutine_self(), host_offset);
2583 ret = bdrv_co_pwritev_part(s->data_file, host_offset,
2584 bytes, qiov, qiov_offset, 0);
2585 if (ret < 0) {
2586 goto out_unlocked;
2587 }
2588 }
2589
2590 qemu_co_mutex_lock(&s->lock);
2591
2592 ret = qcow2_handle_l2meta(bs, &l2meta, true);
2593 goto out_locked;
2594
2595out_unlocked:
2596 qemu_co_mutex_lock(&s->lock);
2597
2598out_locked:
2599 qcow2_handle_l2meta(bs, &l2meta, false);
2600 qemu_co_mutex_unlock(&s->lock);
2601
2602 qemu_vfree(crypt_buf);
2603
2604 return ret;
2605}
2606
2607
2608
2609
2610
2611static coroutine_fn GRAPH_RDLOCK int qcow2_co_pwritev_task_entry(AioTask *task)
2612{
2613 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
2614
2615 assert(!t->subcluster_type);
2616
2617 return qcow2_co_pwritev_task(t->bs, t->host_offset,
2618 t->offset, t->bytes, t->qiov, t->qiov_offset,
2619 t->l2meta);
2620}
2621
2622static int coroutine_fn GRAPH_RDLOCK
2623qcow2_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
2624 QEMUIOVector *qiov, size_t qiov_offset,
2625 BdrvRequestFlags flags)
2626{
2627 BDRVQcow2State *s = bs->opaque;
2628 int offset_in_cluster;
2629 int ret;
2630 unsigned int cur_bytes;
2631 uint64_t host_offset;
2632 QCowL2Meta *l2meta = NULL;
2633 AioTaskPool *aio = NULL;
2634
2635 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
2636
2637 while (bytes != 0 && aio_task_pool_status(aio) == 0) {
2638
2639 l2meta = NULL;
2640
2641 trace_qcow2_writev_start_part(qemu_coroutine_self());
2642 offset_in_cluster = offset_into_cluster(s, offset);
2643 cur_bytes = MIN(bytes, INT_MAX);
2644 if (bs->encrypted) {
2645 cur_bytes = MIN(cur_bytes,
2646 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size
2647 - offset_in_cluster);
2648 }
2649
2650 qemu_co_mutex_lock(&s->lock);
2651
2652 ret = qcow2_alloc_host_offset(bs, offset, &cur_bytes,
2653 &host_offset, &l2meta);
2654 if (ret < 0) {
2655 goto out_locked;
2656 }
2657
2658 ret = qcow2_pre_write_overlap_check(bs, 0, host_offset,
2659 cur_bytes, true);
2660 if (ret < 0) {
2661 goto out_locked;
2662 }
2663
2664 qemu_co_mutex_unlock(&s->lock);
2665
2666 if (!aio && cur_bytes != bytes) {
2667 aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
2668 }
2669 ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_task_entry, 0,
2670 host_offset, offset,
2671 cur_bytes, qiov, qiov_offset, l2meta);
2672 l2meta = NULL;
2673 if (ret < 0) {
2674 goto fail_nometa;
2675 }
2676
2677 bytes -= cur_bytes;
2678 offset += cur_bytes;
2679 qiov_offset += cur_bytes;
2680 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes);
2681 }
2682 ret = 0;
2683
2684 qemu_co_mutex_lock(&s->lock);
2685
2686out_locked:
2687 qcow2_handle_l2meta(bs, &l2meta, false);
2688
2689 qemu_co_mutex_unlock(&s->lock);
2690
2691fail_nometa:
2692 if (aio) {
2693 aio_task_pool_wait_all(aio);
2694 if (ret == 0) {
2695 ret = aio_task_pool_status(aio);
2696 }
2697 g_free(aio);
2698 }
2699
2700 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
2701
2702 return ret;
2703}
2704
2705static int qcow2_inactivate(BlockDriverState *bs)
2706{
2707 BDRVQcow2State *s = bs->opaque;
2708 int ret, result = 0;
2709 Error *local_err = NULL;
2710
2711 qcow2_store_persistent_dirty_bitmaps(bs, true, &local_err);
2712 if (local_err != NULL) {
2713 result = -EINVAL;
2714 error_reportf_err(local_err, "Lost persistent bitmaps during "
2715 "inactivation of node '%s': ",
2716 bdrv_get_device_or_node_name(bs));
2717 }
2718
2719 ret = qcow2_cache_flush(bs, s->l2_table_cache);
2720 if (ret) {
2721 result = ret;
2722 error_report("Failed to flush the L2 table cache: %s",
2723 strerror(-ret));
2724 }
2725
2726 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2727 if (ret) {
2728 result = ret;
2729 error_report("Failed to flush the refcount block cache: %s",
2730 strerror(-ret));
2731 }
2732
2733 if (result == 0) {
2734 qcow2_mark_clean(bs);
2735 }
2736
2737 return result;
2738}
2739
2740static void qcow2_do_close(BlockDriverState *bs, bool close_data_file)
2741{
2742 BDRVQcow2State *s = bs->opaque;
2743 qemu_vfree(s->l1_table);
2744
2745 s->l1_table = NULL;
2746
2747 if (!(s->flags & BDRV_O_INACTIVE)) {
2748 qcow2_inactivate(bs);
2749 }
2750
2751 cache_clean_timer_del(bs);
2752 qcow2_cache_destroy(s->l2_table_cache);
2753 qcow2_cache_destroy(s->refcount_block_cache);
2754
2755 qcrypto_block_free(s->crypto);
2756 s->crypto = NULL;
2757 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
2758
2759 g_free(s->unknown_header_fields);
2760 cleanup_unknown_header_ext(bs);
2761
2762 g_free(s->image_data_file);
2763 g_free(s->image_backing_file);
2764 g_free(s->image_backing_format);
2765
2766 if (close_data_file && has_data_file(bs)) {
2767 bdrv_unref_child(bs, s->data_file);
2768 s->data_file = NULL;
2769 }
2770
2771 qcow2_refcount_close(bs);
2772 qcow2_free_snapshots(bs);
2773}
2774
2775static void qcow2_close(BlockDriverState *bs)
2776{
2777 qcow2_do_close(bs, true);
2778}
2779
2780static void coroutine_fn GRAPH_RDLOCK
2781qcow2_co_invalidate_cache(BlockDriverState *bs, Error **errp)
2782{
2783 ERRP_GUARD();
2784 BDRVQcow2State *s = bs->opaque;
2785 BdrvChild *data_file;
2786 int flags = s->flags;
2787 QCryptoBlock *crypto = NULL;
2788 QDict *options;
2789 int ret;
2790
2791
2792
2793
2794
2795
2796 crypto = s->crypto;
2797 s->crypto = NULL;
2798
2799
2800
2801
2802
2803
2804
2805
2806 qcow2_do_close(bs, false);
2807
2808 data_file = s->data_file;
2809 memset(s, 0, sizeof(BDRVQcow2State));
2810 s->data_file = data_file;
2811
2812 options = qdict_clone_shallow(bs->options);
2813
2814 flags &= ~BDRV_O_INACTIVE;
2815 qemu_co_mutex_lock(&s->lock);
2816 ret = qcow2_do_open(bs, options, flags, false, errp);
2817 qemu_co_mutex_unlock(&s->lock);
2818 qobject_unref(options);
2819 if (ret < 0) {
2820 error_prepend(errp, "Could not reopen qcow2 layer: ");
2821 bs->drv = NULL;
2822 return;
2823 }
2824
2825 s->crypto = crypto;
2826}
2827
2828static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
2829 size_t len, size_t buflen)
2830{
2831 QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
2832 size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
2833
2834 if (buflen < ext_len) {
2835 return -ENOSPC;
2836 }
2837
2838 *ext_backing_fmt = (QCowExtension) {
2839 .magic = cpu_to_be32(magic),
2840 .len = cpu_to_be32(len),
2841 };
2842
2843 if (len) {
2844 memcpy(buf + sizeof(QCowExtension), s, len);
2845 }
2846
2847 return ext_len;
2848}
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858int qcow2_update_header(BlockDriverState *bs)
2859{
2860 BDRVQcow2State *s = bs->opaque;
2861 QCowHeader *header;
2862 char *buf;
2863 size_t buflen = s->cluster_size;
2864 int ret;
2865 uint64_t total_size;
2866 uint32_t refcount_table_clusters;
2867 size_t header_length;
2868 Qcow2UnknownHeaderExtension *uext;
2869
2870 buf = qemu_blockalign(bs, buflen);
2871
2872
2873 header = (QCowHeader*) buf;
2874
2875 if (buflen < sizeof(*header)) {
2876 ret = -ENOSPC;
2877 goto fail;
2878 }
2879
2880 header_length = sizeof(*header) + s->unknown_header_fields_size;
2881 total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
2882 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
2883
2884 ret = validate_compression_type(s, NULL);
2885 if (ret) {
2886 goto fail;
2887 }
2888
2889 *header = (QCowHeader) {
2890
2891 .magic = cpu_to_be32(QCOW_MAGIC),
2892 .version = cpu_to_be32(s->qcow_version),
2893 .backing_file_offset = 0,
2894 .backing_file_size = 0,
2895 .cluster_bits = cpu_to_be32(s->cluster_bits),
2896 .size = cpu_to_be64(total_size),
2897 .crypt_method = cpu_to_be32(s->crypt_method_header),
2898 .l1_size = cpu_to_be32(s->l1_size),
2899 .l1_table_offset = cpu_to_be64(s->l1_table_offset),
2900 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset),
2901 .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
2902 .nb_snapshots = cpu_to_be32(s->nb_snapshots),
2903 .snapshots_offset = cpu_to_be64(s->snapshots_offset),
2904
2905
2906 .incompatible_features = cpu_to_be64(s->incompatible_features),
2907 .compatible_features = cpu_to_be64(s->compatible_features),
2908 .autoclear_features = cpu_to_be64(s->autoclear_features),
2909 .refcount_order = cpu_to_be32(s->refcount_order),
2910 .header_length = cpu_to_be32(header_length),
2911 .compression_type = s->compression_type,
2912 };
2913
2914
2915 switch (s->qcow_version) {
2916 case 2:
2917 ret = offsetof(QCowHeader, incompatible_features);
2918 break;
2919 case 3:
2920 ret = sizeof(*header);
2921 break;
2922 default:
2923 ret = -EINVAL;
2924 goto fail;
2925 }
2926
2927 buf += ret;
2928 buflen -= ret;
2929 memset(buf, 0, buflen);
2930
2931
2932 if (s->unknown_header_fields_size) {
2933 if (buflen < s->unknown_header_fields_size) {
2934 ret = -ENOSPC;
2935 goto fail;
2936 }
2937
2938 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
2939 buf += s->unknown_header_fields_size;
2940 buflen -= s->unknown_header_fields_size;
2941 }
2942
2943
2944 if (s->image_backing_format) {
2945 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
2946 s->image_backing_format,
2947 strlen(s->image_backing_format),
2948 buflen);
2949 if (ret < 0) {
2950 goto fail;
2951 }
2952
2953 buf += ret;
2954 buflen -= ret;
2955 }
2956
2957
2958 if (has_data_file(bs) && s->image_data_file) {
2959 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_DATA_FILE,
2960 s->image_data_file, strlen(s->image_data_file),
2961 buflen);
2962 if (ret < 0) {
2963 goto fail;
2964 }
2965
2966 buf += ret;
2967 buflen -= ret;
2968 }
2969
2970
2971 if (s->crypto_header.offset != 0) {
2972 s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset);
2973 s->crypto_header.length = cpu_to_be64(s->crypto_header.length);
2974 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
2975 &s->crypto_header, sizeof(s->crypto_header),
2976 buflen);
2977 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
2978 s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
2979 if (ret < 0) {
2980 goto fail;
2981 }
2982 buf += ret;
2983 buflen -= ret;
2984 }
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994 if (s->qcow_version >= 3 && s->cluster_size > 4096) {
2995 static const Qcow2Feature features[] = {
2996 {
2997 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2998 .bit = QCOW2_INCOMPAT_DIRTY_BITNR,
2999 .name = "dirty bit",
3000 },
3001 {
3002 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
3003 .bit = QCOW2_INCOMPAT_CORRUPT_BITNR,
3004 .name = "corrupt bit",
3005 },
3006 {
3007 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
3008 .bit = QCOW2_INCOMPAT_DATA_FILE_BITNR,
3009 .name = "external data file",
3010 },
3011 {
3012 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
3013 .bit = QCOW2_INCOMPAT_COMPRESSION_BITNR,
3014 .name = "compression type",
3015 },
3016 {
3017 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
3018 .bit = QCOW2_INCOMPAT_EXTL2_BITNR,
3019 .name = "extended L2 entries",
3020 },
3021 {
3022 .type = QCOW2_FEAT_TYPE_COMPATIBLE,
3023 .bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
3024 .name = "lazy refcounts",
3025 },
3026 {
3027 .type = QCOW2_FEAT_TYPE_AUTOCLEAR,
3028 .bit = QCOW2_AUTOCLEAR_BITMAPS_BITNR,
3029 .name = "bitmaps",
3030 },
3031 {
3032 .type = QCOW2_FEAT_TYPE_AUTOCLEAR,
3033 .bit = QCOW2_AUTOCLEAR_DATA_FILE_RAW_BITNR,
3034 .name = "raw external data",
3035 },
3036 };
3037
3038 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
3039 features, sizeof(features), buflen);
3040 if (ret < 0) {
3041 goto fail;
3042 }
3043 buf += ret;
3044 buflen -= ret;
3045 }
3046
3047
3048 if (s->nb_bitmaps > 0) {
3049 Qcow2BitmapHeaderExt bitmaps_header = {
3050 .nb_bitmaps = cpu_to_be32(s->nb_bitmaps),
3051 .bitmap_directory_size =
3052 cpu_to_be64(s->bitmap_directory_size),
3053 .bitmap_directory_offset =
3054 cpu_to_be64(s->bitmap_directory_offset)
3055 };
3056 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS,
3057 &bitmaps_header, sizeof(bitmaps_header),
3058 buflen);
3059 if (ret < 0) {
3060 goto fail;
3061 }
3062 buf += ret;
3063 buflen -= ret;
3064 }
3065
3066
3067 QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
3068 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
3069 if (ret < 0) {
3070 goto fail;
3071 }
3072
3073 buf += ret;
3074 buflen -= ret;
3075 }
3076
3077
3078 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
3079 if (ret < 0) {
3080 goto fail;
3081 }
3082
3083 buf += ret;
3084 buflen -= ret;
3085
3086
3087 if (s->image_backing_file) {
3088 size_t backing_file_len = strlen(s->image_backing_file);
3089
3090 if (buflen < backing_file_len) {
3091 ret = -ENOSPC;
3092 goto fail;
3093 }
3094
3095
3096 strncpy(buf, s->image_backing_file, buflen);
3097
3098 header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
3099 header->backing_file_size = cpu_to_be32(backing_file_len);
3100 }
3101
3102
3103 ret = bdrv_pwrite(bs->file, 0, s->cluster_size, header, 0);
3104 if (ret < 0) {
3105 goto fail;
3106 }
3107
3108 ret = 0;
3109fail:
3110 qemu_vfree(header);
3111 return ret;
3112}
3113
3114static int qcow2_change_backing_file(BlockDriverState *bs,
3115 const char *backing_file, const char *backing_fmt)
3116{
3117 BDRVQcow2State *s = bs->opaque;
3118
3119
3120
3121 if (backing_file && data_file_is_raw(bs)) {
3122 return -EINVAL;
3123 }
3124
3125 if (backing_file && strlen(backing_file) > 1023) {
3126 return -EINVAL;
3127 }
3128
3129 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
3130 backing_file ?: "");
3131 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
3132 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
3133
3134 g_free(s->image_backing_file);
3135 g_free(s->image_backing_format);
3136
3137 s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
3138 s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
3139
3140 return qcow2_update_header(bs);
3141}
3142
3143static int qcow2_set_up_encryption(BlockDriverState *bs,
3144 QCryptoBlockCreateOptions *cryptoopts,
3145 Error **errp)
3146{
3147 BDRVQcow2State *s = bs->opaque;
3148 QCryptoBlock *crypto = NULL;
3149 int fmt, ret;
3150
3151 switch (cryptoopts->format) {
3152 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
3153 fmt = QCOW_CRYPT_LUKS;
3154 break;
3155 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
3156 fmt = QCOW_CRYPT_AES;
3157 break;
3158 default:
3159 error_setg(errp, "Crypto format not supported in qcow2");
3160 return -EINVAL;
3161 }
3162
3163 s->crypt_method_header = fmt;
3164
3165 crypto = qcrypto_block_create(cryptoopts, "encrypt.",
3166 qcow2_crypto_hdr_init_func,
3167 qcow2_crypto_hdr_write_func,
3168 bs, errp);
3169 if (!crypto) {
3170 return -EINVAL;
3171 }
3172
3173 ret = qcow2_update_header(bs);
3174 if (ret < 0) {
3175 error_setg_errno(errp, -ret, "Could not write encryption header");
3176 goto out;
3177 }
3178
3179 ret = 0;
3180 out:
3181 qcrypto_block_free(crypto);
3182 return ret;
3183}
3184
3185
3186
3187
3188
3189
3190
3191
3192static int coroutine_fn GRAPH_RDLOCK
3193preallocate_co(BlockDriverState *bs, uint64_t offset, uint64_t new_length,
3194 PreallocMode mode, Error **errp)
3195{
3196 BDRVQcow2State *s = bs->opaque;
3197 uint64_t bytes;
3198 uint64_t host_offset = 0;
3199 int64_t file_length;
3200 unsigned int cur_bytes;
3201 int ret;
3202 QCowL2Meta *meta = NULL, *m;
3203
3204 assert(offset <= new_length);
3205 bytes = new_length - offset;
3206
3207 while (bytes) {
3208 cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size));
3209 ret = qcow2_alloc_host_offset(bs, offset, &cur_bytes,
3210 &host_offset, &meta);
3211 if (ret < 0) {
3212 error_setg_errno(errp, -ret, "Allocating clusters failed");
3213 goto out;
3214 }
3215
3216 for (m = meta; m != NULL; m = m->next) {
3217 m->prealloc = true;
3218 }
3219
3220 ret = qcow2_handle_l2meta(bs, &meta, true);
3221 if (ret < 0) {
3222 error_setg_errno(errp, -ret, "Mapping clusters failed");
3223 goto out;
3224 }
3225
3226
3227
3228 bytes -= cur_bytes;
3229 offset += cur_bytes;
3230 }
3231
3232
3233
3234
3235
3236
3237 file_length = bdrv_getlength(s->data_file->bs);
3238 if (file_length < 0) {
3239 error_setg_errno(errp, -file_length, "Could not get file size");
3240 ret = file_length;
3241 goto out;
3242 }
3243
3244 if (host_offset + cur_bytes > file_length) {
3245 if (mode == PREALLOC_MODE_METADATA) {
3246 mode = PREALLOC_MODE_OFF;
3247 }
3248 ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
3249 mode, 0, errp);
3250 if (ret < 0) {
3251 goto out;
3252 }
3253 }
3254
3255 ret = 0;
3256
3257out:
3258 qcow2_handle_l2meta(bs, &meta, false);
3259 return ret;
3260}
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
3272 int refcount_order, bool generous_increase,
3273 uint64_t *refblock_count)
3274{
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284 int64_t blocks_per_table_cluster = cluster_size / REFTABLE_ENTRY_SIZE;
3285 int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order);
3286 int64_t table = 0;
3287 int64_t blocks = 0;
3288 int64_t last;
3289 int64_t n = 0;
3290
3291 do {
3292 last = n;
3293 blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block);
3294 table = DIV_ROUND_UP(blocks, blocks_per_table_cluster);
3295 n = clusters + blocks + table;
3296
3297 if (n == last && generous_increase) {
3298 clusters += DIV_ROUND_UP(table, 2);
3299 n = 0;
3300 generous_increase = false;
3301 }
3302 } while (n != last);
3303
3304 if (refblock_count) {
3305 *refblock_count = blocks;
3306 }
3307
3308 return (blocks + table) * cluster_size;
3309}
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321static int64_t qcow2_calc_prealloc_size(int64_t total_size,
3322 size_t cluster_size,
3323 int refcount_order,
3324 bool extended_l2)
3325{
3326 int64_t meta_size = 0;
3327 uint64_t nl1e, nl2e;
3328 int64_t aligned_total_size = ROUND_UP(total_size, cluster_size);
3329 size_t l2e_size = extended_l2 ? L2E_SIZE_EXTENDED : L2E_SIZE_NORMAL;
3330
3331
3332 meta_size += cluster_size;
3333
3334
3335 nl2e = aligned_total_size / cluster_size;
3336 nl2e = ROUND_UP(nl2e, cluster_size / l2e_size);
3337 meta_size += nl2e * l2e_size;
3338
3339
3340 nl1e = nl2e * l2e_size / cluster_size;
3341 nl1e = ROUND_UP(nl1e, cluster_size / L1E_SIZE);
3342 meta_size += nl1e * L1E_SIZE;
3343
3344
3345 meta_size += qcow2_refcount_metadata_size(
3346 (meta_size + aligned_total_size) / cluster_size,
3347 cluster_size, refcount_order, false, NULL);
3348
3349 return meta_size + aligned_total_size;
3350}
3351
3352static bool validate_cluster_size(size_t cluster_size, bool extended_l2,
3353 Error **errp)
3354{
3355 int cluster_bits = ctz32(cluster_size);
3356 if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
3357 (1 << cluster_bits) != cluster_size)
3358 {
3359 error_setg(errp, "Cluster size must be a power of two between %d and "
3360 "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
3361 return false;
3362 }
3363
3364 if (extended_l2) {
3365 unsigned min_cluster_size =
3366 (1 << MIN_CLUSTER_BITS) * QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER;
3367 if (cluster_size < min_cluster_size) {
3368 error_setg(errp, "Extended L2 entries are only supported with "
3369 "cluster sizes of at least %u bytes", min_cluster_size);
3370 return false;
3371 }
3372 }
3373
3374 return true;
3375}
3376
3377static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, bool extended_l2,
3378 Error **errp)
3379{
3380 size_t cluster_size;
3381
3382 cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
3383 DEFAULT_CLUSTER_SIZE);
3384 if (!validate_cluster_size(cluster_size, extended_l2, errp)) {
3385 return 0;
3386 }
3387 return cluster_size;
3388}
3389
3390static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp)
3391{
3392 char *buf;
3393 int ret;
3394
3395 buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
3396 if (!buf) {
3397 ret = 3;
3398 } else if (!strcmp(buf, "0.10")) {
3399 ret = 2;
3400 } else if (!strcmp(buf, "1.1")) {
3401 ret = 3;
3402 } else {
3403 error_setg(errp, "Invalid compatibility level: '%s'", buf);
3404 ret = -EINVAL;
3405 }
3406 g_free(buf);
3407 return ret;
3408}
3409
3410static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
3411 Error **errp)
3412{
3413 uint64_t refcount_bits;
3414
3415 refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16);
3416 if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
3417 error_setg(errp, "Refcount width must be a power of two and may not "
3418 "exceed 64 bits");
3419 return 0;
3420 }
3421
3422 if (version < 3 && refcount_bits != 16) {
3423 error_setg(errp, "Different refcount widths than 16 bits require "
3424 "compatibility level 1.1 or above (use compat=1.1 or "
3425 "greater)");
3426 return 0;
3427 }
3428
3429 return refcount_bits;
3430}
3431
3432static int coroutine_fn
3433qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
3434{
3435 BlockdevCreateOptionsQcow2 *qcow2_opts;
3436 QDict *options;
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450 BlockBackend *blk = NULL;
3451 BlockDriverState *bs = NULL;
3452 BlockDriverState *data_bs = NULL;
3453 QCowHeader *header;
3454 size_t cluster_size;
3455 int version;
3456 int refcount_order;
3457 uint64_t *refcount_table;
3458 int ret;
3459 uint8_t compression_type = QCOW2_COMPRESSION_TYPE_ZLIB;
3460
3461 assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2);
3462 qcow2_opts = &create_options->u.qcow2;
3463
3464 bs = bdrv_co_open_blockdev_ref(qcow2_opts->file, errp);
3465 if (bs == NULL) {
3466 return -EIO;
3467 }
3468
3469
3470 if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) {
3471 error_setg(errp, "Image size must be a multiple of %u bytes",
3472 (unsigned) BDRV_SECTOR_SIZE);
3473 ret = -EINVAL;
3474 goto out;
3475 }
3476
3477 if (qcow2_opts->has_version) {
3478 switch (qcow2_opts->version) {
3479 case BLOCKDEV_QCOW2_VERSION_V2:
3480 version = 2;
3481 break;
3482 case BLOCKDEV_QCOW2_VERSION_V3:
3483 version = 3;
3484 break;
3485 default:
3486 g_assert_not_reached();
3487 }
3488 } else {
3489 version = 3;
3490 }
3491
3492 if (qcow2_opts->has_cluster_size) {
3493 cluster_size = qcow2_opts->cluster_size;
3494 } else {
3495 cluster_size = DEFAULT_CLUSTER_SIZE;
3496 }
3497
3498 if (!qcow2_opts->has_extended_l2) {
3499 qcow2_opts->extended_l2 = false;
3500 }
3501 if (qcow2_opts->extended_l2) {
3502 if (version < 3) {
3503 error_setg(errp, "Extended L2 entries are only supported with "
3504 "compatibility level 1.1 and above (use version=v3 or "
3505 "greater)");
3506 ret = -EINVAL;
3507 goto out;
3508 }
3509 }
3510
3511 if (!validate_cluster_size(cluster_size, qcow2_opts->extended_l2, errp)) {
3512 ret = -EINVAL;
3513 goto out;
3514 }
3515
3516 if (!qcow2_opts->has_preallocation) {
3517 qcow2_opts->preallocation = PREALLOC_MODE_OFF;
3518 }
3519 if (qcow2_opts->backing_file &&
3520 qcow2_opts->preallocation != PREALLOC_MODE_OFF &&
3521 !qcow2_opts->extended_l2)
3522 {
3523 error_setg(errp, "Backing file and preallocation can only be used at "
3524 "the same time if extended_l2 is on");
3525 ret = -EINVAL;
3526 goto out;
3527 }
3528 if (qcow2_opts->has_backing_fmt && !qcow2_opts->backing_file) {
3529 error_setg(errp, "Backing format cannot be used without backing file");
3530 ret = -EINVAL;
3531 goto out;
3532 }
3533
3534 if (!qcow2_opts->has_lazy_refcounts) {
3535 qcow2_opts->lazy_refcounts = false;
3536 }
3537 if (version < 3 && qcow2_opts->lazy_refcounts) {
3538 error_setg(errp, "Lazy refcounts only supported with compatibility "
3539 "level 1.1 and above (use version=v3 or greater)");
3540 ret = -EINVAL;
3541 goto out;
3542 }
3543
3544 if (!qcow2_opts->has_refcount_bits) {
3545 qcow2_opts->refcount_bits = 16;
3546 }
3547 if (qcow2_opts->refcount_bits > 64 ||
3548 !is_power_of_2(qcow2_opts->refcount_bits))
3549 {
3550 error_setg(errp, "Refcount width must be a power of two and may not "
3551 "exceed 64 bits");
3552 ret = -EINVAL;
3553 goto out;
3554 }
3555 if (version < 3 && qcow2_opts->refcount_bits != 16) {
3556 error_setg(errp, "Different refcount widths than 16 bits require "
3557 "compatibility level 1.1 or above (use version=v3 or "
3558 "greater)");
3559 ret = -EINVAL;
3560 goto out;
3561 }
3562 refcount_order = ctz32(qcow2_opts->refcount_bits);
3563
3564 if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) {
3565 error_setg(errp, "data-file-raw requires data-file");
3566 ret = -EINVAL;
3567 goto out;
3568 }
3569 if (qcow2_opts->data_file_raw && qcow2_opts->backing_file) {
3570 error_setg(errp, "Backing file and data-file-raw cannot be used at "
3571 "the same time");
3572 ret = -EINVAL;
3573 goto out;
3574 }
3575 if (qcow2_opts->data_file_raw &&
3576 qcow2_opts->preallocation == PREALLOC_MODE_OFF)
3577 {
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588 qcow2_opts->preallocation = PREALLOC_MODE_METADATA;
3589
3590
3591
3592
3593
3594
3595 assert(!qcow2_opts->backing_file);
3596 }
3597
3598 if (qcow2_opts->data_file) {
3599 if (version < 3) {
3600 error_setg(errp, "External data files are only supported with "
3601 "compatibility level 1.1 and above (use version=v3 or "
3602 "greater)");
3603 ret = -EINVAL;
3604 goto out;
3605 }
3606 data_bs = bdrv_co_open_blockdev_ref(qcow2_opts->data_file, errp);
3607 if (data_bs == NULL) {
3608 ret = -EIO;
3609 goto out;
3610 }
3611 }
3612
3613 if (qcow2_opts->has_compression_type &&
3614 qcow2_opts->compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) {
3615
3616 ret = -EINVAL;
3617
3618 if (version < 3) {
3619 error_setg(errp, "Non-zlib compression type is only supported with "
3620 "compatibility level 1.1 and above (use version=v3 or "
3621 "greater)");
3622 goto out;
3623 }
3624
3625 switch (qcow2_opts->compression_type) {
3626#ifdef CONFIG_ZSTD
3627 case QCOW2_COMPRESSION_TYPE_ZSTD:
3628 break;
3629#endif
3630 default:
3631 error_setg(errp, "Unknown compression type");
3632 goto out;
3633 }
3634
3635 compression_type = qcow2_opts->compression_type;
3636 }
3637
3638
3639 blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
3640 errp);
3641 if (!blk) {
3642 ret = -EPERM;
3643 goto out;
3644 }
3645 blk_set_allow_write_beyond_eof(blk, true);
3646
3647
3648 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
3649 header = g_malloc0(cluster_size);
3650 *header = (QCowHeader) {
3651 .magic = cpu_to_be32(QCOW_MAGIC),
3652 .version = cpu_to_be32(version),
3653 .cluster_bits = cpu_to_be32(ctz32(cluster_size)),
3654 .size = cpu_to_be64(0),
3655 .l1_table_offset = cpu_to_be64(0),
3656 .l1_size = cpu_to_be32(0),
3657 .refcount_table_offset = cpu_to_be64(cluster_size),
3658 .refcount_table_clusters = cpu_to_be32(1),
3659 .refcount_order = cpu_to_be32(refcount_order),
3660
3661 .compression_type = compression_type,
3662 .header_length = cpu_to_be32(sizeof(*header)),
3663 };
3664
3665
3666 header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
3667
3668 if (qcow2_opts->lazy_refcounts) {
3669 header->compatible_features |=
3670 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
3671 }
3672 if (data_bs) {
3673 header->incompatible_features |=
3674 cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE);
3675 }
3676 if (qcow2_opts->data_file_raw) {
3677 header->autoclear_features |=
3678 cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW);
3679 }
3680 if (compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) {
3681 header->incompatible_features |=
3682 cpu_to_be64(QCOW2_INCOMPAT_COMPRESSION);
3683 }
3684
3685 if (qcow2_opts->extended_l2) {
3686 header->incompatible_features |=
3687 cpu_to_be64(QCOW2_INCOMPAT_EXTL2);
3688 }
3689
3690 ret = blk_co_pwrite(blk, 0, cluster_size, header, 0);
3691 g_free(header);
3692 if (ret < 0) {
3693 error_setg_errno(errp, -ret, "Could not write qcow2 header");
3694 goto out;
3695 }
3696
3697
3698 refcount_table = g_malloc0(2 * cluster_size);
3699 refcount_table[0] = cpu_to_be64(2 * cluster_size);
3700 ret = blk_co_pwrite(blk, cluster_size, 2 * cluster_size, refcount_table, 0);
3701 g_free(refcount_table);
3702
3703 if (ret < 0) {
3704 error_setg_errno(errp, -ret, "Could not write refcount table");
3705 goto out;
3706 }
3707
3708 blk_co_unref(blk);
3709 blk = NULL;
3710
3711
3712
3713
3714
3715
3716 options = qdict_new();
3717 qdict_put_str(options, "driver", "qcow2");
3718 qdict_put_str(options, "file", bs->node_name);
3719 if (data_bs) {
3720 qdict_put_str(options, "data-file", data_bs->node_name);
3721 }
3722 blk = blk_co_new_open(NULL, NULL, options,
3723 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
3724 errp);
3725 if (blk == NULL) {
3726 ret = -EIO;
3727 goto out;
3728 }
3729
3730 ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
3731 if (ret < 0) {
3732 error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
3733 "header and refcount table");
3734 goto out;
3735
3736 } else if (ret != 0) {
3737 error_report("Huh, first cluster in empty image is already in use?");
3738 abort();
3739 }
3740
3741
3742 if (data_bs) {
3743 BDRVQcow2State *s = blk_bs(blk)->opaque;
3744 s->image_data_file = g_strdup(data_bs->filename);
3745 }
3746
3747
3748 ret = qcow2_update_header(blk_bs(blk));
3749 if (ret < 0) {
3750 error_setg_errno(errp, -ret, "Could not update qcow2 header");
3751 goto out;
3752 }
3753
3754
3755 ret = blk_co_truncate(blk, qcow2_opts->size, false,
3756 qcow2_opts->preallocation, 0, errp);
3757 if (ret < 0) {
3758 error_prepend(errp, "Could not resize image: ");
3759 goto out;
3760 }
3761
3762
3763 if (qcow2_opts->backing_file) {
3764 const char *backing_format = NULL;
3765
3766 if (qcow2_opts->has_backing_fmt) {
3767 backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt);
3768 }
3769
3770 ret = bdrv_change_backing_file(blk_bs(blk), qcow2_opts->backing_file,
3771 backing_format, false);
3772 if (ret < 0) {
3773 error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
3774 "with format '%s'", qcow2_opts->backing_file,
3775 backing_format);
3776 goto out;
3777 }
3778 }
3779
3780
3781 if (qcow2_opts->encrypt) {
3782 ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
3783 if (ret < 0) {
3784 goto out;
3785 }
3786 }
3787
3788 blk_co_unref(blk);
3789 blk = NULL;
3790
3791
3792
3793
3794
3795
3796
3797 options = qdict_new();
3798 qdict_put_str(options, "driver", "qcow2");
3799 qdict_put_str(options, "file", bs->node_name);
3800 if (data_bs) {
3801 qdict_put_str(options, "data-file", data_bs->node_name);
3802 }
3803 blk = blk_co_new_open(NULL, NULL, options,
3804 BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
3805 errp);
3806 if (blk == NULL) {
3807 ret = -EIO;
3808 goto out;
3809 }
3810
3811 ret = 0;
3812out:
3813 blk_co_unref(blk);
3814 bdrv_co_unref(bs);
3815 bdrv_co_unref(data_bs);
3816 return ret;
3817}
3818
3819static int coroutine_fn GRAPH_RDLOCK
3820qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
3821 Error **errp)
3822{
3823 BlockdevCreateOptions *create_options = NULL;
3824 QDict *qdict;
3825 Visitor *v;
3826 BlockDriverState *bs = NULL;
3827 BlockDriverState *data_bs = NULL;
3828 const char *val;
3829 int ret;
3830
3831
3832
3833
3834
3835 qdict = qemu_opts_to_qdict_filtered(opts, NULL, bdrv_qcow2.create_opts,
3836 true);
3837
3838
3839 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT);
3840 if (val && !strcmp(val, "on")) {
3841 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow");
3842 } else if (val && !strcmp(val, "off")) {
3843 qdict_del(qdict, BLOCK_OPT_ENCRYPT);
3844 }
3845
3846 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT);
3847 if (val && !strcmp(val, "aes")) {
3848 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow");
3849 }
3850
3851
3852
3853 val = qdict_get_try_str(qdict, BLOCK_OPT_COMPAT_LEVEL);
3854 if (val && !strcmp(val, "0.10")) {
3855 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v2");
3856 } else if (val && !strcmp(val, "1.1")) {
3857 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v3");
3858 }
3859
3860
3861 static const QDictRenames opt_renames[] = {
3862 { BLOCK_OPT_BACKING_FILE, "backing-file" },
3863 { BLOCK_OPT_BACKING_FMT, "backing-fmt" },
3864 { BLOCK_OPT_CLUSTER_SIZE, "cluster-size" },
3865 { BLOCK_OPT_LAZY_REFCOUNTS, "lazy-refcounts" },
3866 { BLOCK_OPT_EXTL2, "extended-l2" },
3867 { BLOCK_OPT_REFCOUNT_BITS, "refcount-bits" },
3868 { BLOCK_OPT_ENCRYPT, BLOCK_OPT_ENCRYPT_FORMAT },
3869 { BLOCK_OPT_COMPAT_LEVEL, "version" },
3870 { BLOCK_OPT_DATA_FILE_RAW, "data-file-raw" },
3871 { BLOCK_OPT_COMPRESSION_TYPE, "compression-type" },
3872 { NULL, NULL },
3873 };
3874
3875 if (!qdict_rename_keys(qdict, opt_renames, errp)) {
3876 ret = -EINVAL;
3877 goto finish;
3878 }
3879
3880
3881 ret = bdrv_co_create_file(filename, opts, errp);
3882 if (ret < 0) {
3883 goto finish;
3884 }
3885
3886 bs = bdrv_co_open(filename, NULL, NULL,
3887 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
3888 if (bs == NULL) {
3889 ret = -EIO;
3890 goto finish;
3891 }
3892
3893
3894 val = qdict_get_try_str(qdict, BLOCK_OPT_DATA_FILE);
3895 if (val) {
3896 ret = bdrv_co_create_file(val, opts, errp);
3897 if (ret < 0) {
3898 goto finish;
3899 }
3900
3901 data_bs = bdrv_co_open(val, NULL, NULL,
3902 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
3903 errp);
3904 if (data_bs == NULL) {
3905 ret = -EIO;
3906 goto finish;
3907 }
3908
3909 qdict_del(qdict, BLOCK_OPT_DATA_FILE);
3910 qdict_put_str(qdict, "data-file", data_bs->node_name);
3911 }
3912
3913
3914 qdict_put_str(qdict, "driver", "qcow2");
3915 qdict_put_str(qdict, "file", bs->node_name);
3916
3917
3918 v = qobject_input_visitor_new_flat_confused(qdict, errp);
3919 if (!v) {
3920 ret = -EINVAL;
3921 goto finish;
3922 }
3923
3924 visit_type_BlockdevCreateOptions(v, NULL, &create_options, errp);
3925 visit_free(v);
3926 if (!create_options) {
3927 ret = -EINVAL;
3928 goto finish;
3929 }
3930
3931
3932 create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size,
3933 BDRV_SECTOR_SIZE);
3934
3935
3936 ret = qcow2_co_create(create_options, errp);
3937finish:
3938 if (ret < 0) {
3939 bdrv_co_delete_file_noerr(bs);
3940 bdrv_co_delete_file_noerr(data_bs);
3941 } else {
3942 ret = 0;
3943 }
3944
3945 qobject_unref(qdict);
3946 bdrv_co_unref(bs);
3947 bdrv_co_unref(data_bs);
3948 qapi_free_BlockdevCreateOptions(create_options);
3949 return ret;
3950}
3951
3952
3953static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
3954{
3955 int64_t nr;
3956 int res;
3957
3958
3959 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3960 bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset;
3961 }
3962
3963 if (!bytes) {
3964 return true;
3965 }
3966
3967
3968
3969
3970
3971
3972
3973 do {
3974 res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
3975 offset += nr;
3976 bytes -= nr;
3977 } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);
3978
3979 return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
3980}
3981
3982static int coroutine_fn GRAPH_RDLOCK
3983qcow2_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
3984 BdrvRequestFlags flags)
3985{
3986 int ret;
3987 BDRVQcow2State *s = bs->opaque;
3988
3989 uint32_t head = offset_into_subcluster(s, offset);
3990 uint32_t tail = ROUND_UP(offset + bytes, s->subcluster_size) -
3991 (offset + bytes);
3992
3993 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes);
3994 if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) {
3995 tail = 0;
3996 }
3997
3998 if (head || tail) {
3999 uint64_t off;
4000 unsigned int nr;
4001 QCow2SubclusterType type;
4002
4003 assert(head + bytes + tail <= s->subcluster_size);
4004
4005
4006 if (!(is_zero(bs, offset - head, head) &&
4007 is_zero(bs, offset + bytes, tail))) {
4008 return -ENOTSUP;
4009 }
4010
4011 qemu_co_mutex_lock(&s->lock);
4012
4013 offset -= head;
4014 bytes = s->subcluster_size;
4015 nr = s->subcluster_size;
4016 ret = qcow2_get_host_offset(bs, offset, &nr, &off, &type);
4017 if (ret < 0 ||
4018 (type != QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN &&
4019 type != QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC &&
4020 type != QCOW2_SUBCLUSTER_ZERO_PLAIN &&
4021 type != QCOW2_SUBCLUSTER_ZERO_ALLOC)) {
4022 qemu_co_mutex_unlock(&s->lock);
4023 return ret < 0 ? ret : -ENOTSUP;
4024 }
4025 } else {
4026 qemu_co_mutex_lock(&s->lock);
4027 }
4028
4029 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes);
4030
4031
4032 ret = qcow2_subcluster_zeroize(bs, offset, bytes, flags);
4033 qemu_co_mutex_unlock(&s->lock);
4034
4035 return ret;
4036}
4037
4038static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
4039 int64_t offset, int64_t bytes)
4040{
4041 int ret;
4042 BDRVQcow2State *s = bs->opaque;
4043
4044
4045
4046 if (s->qcow_version < 3 && bs->backing) {
4047 return -ENOTSUP;
4048 }
4049
4050 if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) {
4051 assert(bytes < s->cluster_size);
4052
4053
4054 if (!QEMU_IS_ALIGNED(offset, s->cluster_size) ||
4055 offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) {
4056 return -ENOTSUP;
4057 }
4058 }
4059
4060 qemu_co_mutex_lock(&s->lock);
4061 ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST,
4062 false);
4063 qemu_co_mutex_unlock(&s->lock);
4064 return ret;
4065}
4066
4067static int coroutine_fn GRAPH_RDLOCK
4068qcow2_co_copy_range_from(BlockDriverState *bs,
4069 BdrvChild *src, int64_t src_offset,
4070 BdrvChild *dst, int64_t dst_offset,
4071 int64_t bytes, BdrvRequestFlags read_flags,
4072 BdrvRequestFlags write_flags)
4073{
4074 BDRVQcow2State *s = bs->opaque;
4075 int ret;
4076 unsigned int cur_bytes;
4077 BdrvChild *child = NULL;
4078 BdrvRequestFlags cur_write_flags;
4079
4080 assert(!bs->encrypted);
4081 qemu_co_mutex_lock(&s->lock);
4082
4083 while (bytes != 0) {
4084 uint64_t copy_offset = 0;
4085 QCow2SubclusterType type;
4086
4087 cur_bytes = MIN(bytes, INT_MAX);
4088 cur_write_flags = write_flags;
4089
4090 ret = qcow2_get_host_offset(bs, src_offset, &cur_bytes,
4091 ©_offset, &type);
4092 if (ret < 0) {
4093 goto out;
4094 }
4095
4096 switch (type) {
4097 case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
4098 case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
4099 if (bs->backing && bs->backing->bs) {
4100 int64_t backing_length = bdrv_getlength(bs->backing->bs);
4101 if (src_offset >= backing_length) {
4102 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4103 } else {
4104 child = bs->backing;
4105 cur_bytes = MIN(cur_bytes, backing_length - src_offset);
4106 copy_offset = src_offset;
4107 }
4108 } else {
4109 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4110 }
4111 break;
4112
4113 case QCOW2_SUBCLUSTER_ZERO_PLAIN:
4114 case QCOW2_SUBCLUSTER_ZERO_ALLOC:
4115 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4116 break;
4117
4118 case QCOW2_SUBCLUSTER_COMPRESSED:
4119 ret = -ENOTSUP;
4120 goto out;
4121
4122 case QCOW2_SUBCLUSTER_NORMAL:
4123 child = s->data_file;
4124 break;
4125
4126 default:
4127 abort();
4128 }
4129 qemu_co_mutex_unlock(&s->lock);
4130 ret = bdrv_co_copy_range_from(child,
4131 copy_offset,
4132 dst, dst_offset,
4133 cur_bytes, read_flags, cur_write_flags);
4134 qemu_co_mutex_lock(&s->lock);
4135 if (ret < 0) {
4136 goto out;
4137 }
4138
4139 bytes -= cur_bytes;
4140 src_offset += cur_bytes;
4141 dst_offset += cur_bytes;
4142 }
4143 ret = 0;
4144
4145out:
4146 qemu_co_mutex_unlock(&s->lock);
4147 return ret;
4148}
4149
4150static int coroutine_fn GRAPH_RDLOCK
4151qcow2_co_copy_range_to(BlockDriverState *bs,
4152 BdrvChild *src, int64_t src_offset,
4153 BdrvChild *dst, int64_t dst_offset,
4154 int64_t bytes, BdrvRequestFlags read_flags,
4155 BdrvRequestFlags write_flags)
4156{
4157 BDRVQcow2State *s = bs->opaque;
4158 int ret;
4159 unsigned int cur_bytes;
4160 uint64_t host_offset;
4161 QCowL2Meta *l2meta = NULL;
4162
4163 assert(!bs->encrypted);
4164
4165 qemu_co_mutex_lock(&s->lock);
4166
4167 while (bytes != 0) {
4168
4169 l2meta = NULL;
4170
4171 cur_bytes = MIN(bytes, INT_MAX);
4172
4173
4174
4175
4176
4177 ret = qcow2_alloc_host_offset(bs, dst_offset, &cur_bytes,
4178 &host_offset, &l2meta);
4179 if (ret < 0) {
4180 goto fail;
4181 }
4182
4183 ret = qcow2_pre_write_overlap_check(bs, 0, host_offset, cur_bytes,
4184 true);
4185 if (ret < 0) {
4186 goto fail;
4187 }
4188
4189 qemu_co_mutex_unlock(&s->lock);
4190 ret = bdrv_co_copy_range_to(src, src_offset, s->data_file, host_offset,
4191 cur_bytes, read_flags, write_flags);
4192 qemu_co_mutex_lock(&s->lock);
4193 if (ret < 0) {
4194 goto fail;
4195 }
4196
4197 ret = qcow2_handle_l2meta(bs, &l2meta, true);
4198 if (ret) {
4199 goto fail;
4200 }
4201
4202 bytes -= cur_bytes;
4203 src_offset += cur_bytes;
4204 dst_offset += cur_bytes;
4205 }
4206 ret = 0;
4207
4208fail:
4209 qcow2_handle_l2meta(bs, &l2meta, false);
4210
4211 qemu_co_mutex_unlock(&s->lock);
4212
4213 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
4214
4215 return ret;
4216}
4217
4218static int coroutine_fn GRAPH_RDLOCK
4219qcow2_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
4220 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
4221{
4222 BDRVQcow2State *s = bs->opaque;
4223 uint64_t old_length;
4224 int64_t new_l1_size;
4225 int ret;
4226 QDict *options;
4227
4228 if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA &&
4229 prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL)
4230 {
4231 error_setg(errp, "Unsupported preallocation mode '%s'",
4232 PreallocMode_str(prealloc));
4233 return -ENOTSUP;
4234 }
4235
4236 if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {
4237 error_setg(errp, "The new size must be a multiple of %u",
4238 (unsigned) BDRV_SECTOR_SIZE);
4239 return -EINVAL;
4240 }
4241
4242 qemu_co_mutex_lock(&s->lock);
4243
4244
4245
4246
4247
4248 if (s->nb_snapshots && s->qcow_version < 3) {
4249 error_setg(errp, "Can't resize a v2 image which has snapshots");
4250 ret = -ENOTSUP;
4251 goto fail;
4252 }
4253
4254
4255 if (qcow2_truncate_bitmaps_check(bs, errp)) {
4256 ret = -ENOTSUP;
4257 goto fail;
4258 }
4259
4260 old_length = bs->total_sectors * BDRV_SECTOR_SIZE;
4261 new_l1_size = size_to_l1(s, offset);
4262
4263 if (offset < old_length) {
4264 int64_t last_cluster, old_file_size;
4265 if (prealloc != PREALLOC_MODE_OFF) {
4266 error_setg(errp,
4267 "Preallocation can't be used for shrinking an image");
4268 ret = -EINVAL;
4269 goto fail;
4270 }
4271
4272 ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size),
4273 old_length - ROUND_UP(offset,
4274 s->cluster_size),
4275 QCOW2_DISCARD_ALWAYS, true);
4276 if (ret < 0) {
4277 error_setg_errno(errp, -ret, "Failed to discard cropped clusters");
4278 goto fail;
4279 }
4280
4281 ret = qcow2_shrink_l1_table(bs, new_l1_size);
4282 if (ret < 0) {
4283 error_setg_errno(errp, -ret,
4284 "Failed to reduce the number of L2 tables");
4285 goto fail;
4286 }
4287
4288 ret = qcow2_shrink_reftable(bs);
4289 if (ret < 0) {
4290 error_setg_errno(errp, -ret,
4291 "Failed to discard unused refblocks");
4292 goto fail;
4293 }
4294
4295 old_file_size = bdrv_getlength(bs->file->bs);
4296 if (old_file_size < 0) {
4297 error_setg_errno(errp, -old_file_size,
4298 "Failed to inquire current file length");
4299 ret = old_file_size;
4300 goto fail;
4301 }
4302 last_cluster = qcow2_get_last_cluster(bs, old_file_size);
4303 if (last_cluster < 0) {
4304 error_setg_errno(errp, -last_cluster,
4305 "Failed to find the last cluster");
4306 ret = last_cluster;
4307 goto fail;
4308 }
4309 if ((last_cluster + 1) * s->cluster_size < old_file_size) {
4310 Error *local_err = NULL;
4311
4312
4313
4314
4315
4316
4317
4318
4319 bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
4320 false, PREALLOC_MODE_OFF, 0, &local_err);
4321 if (local_err) {
4322 warn_reportf_err(local_err,
4323 "Failed to truncate the tail of the image: ");
4324 }
4325 }
4326 } else {
4327 ret = qcow2_grow_l1_table(bs, new_l1_size, true);
4328 if (ret < 0) {
4329 error_setg_errno(errp, -ret, "Failed to grow the L1 table");
4330 goto fail;
4331 }
4332
4333 if (data_file_is_raw(bs) && prealloc == PREALLOC_MODE_OFF) {
4334
4335
4336
4337
4338
4339
4340
4341
4342 prealloc = PREALLOC_MODE_METADATA;
4343 }
4344 }
4345
4346 switch (prealloc) {
4347 case PREALLOC_MODE_OFF:
4348 if (has_data_file(bs)) {
4349
4350
4351
4352
4353
4354 ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
4355 errp);
4356 if (ret < 0) {
4357 goto fail;
4358 }
4359 }
4360 break;
4361
4362 case PREALLOC_MODE_METADATA:
4363 ret = preallocate_co(bs, old_length, offset, prealloc, errp);
4364 if (ret < 0) {
4365 goto fail;
4366 }
4367 break;
4368
4369 case PREALLOC_MODE_FALLOC:
4370 case PREALLOC_MODE_FULL:
4371 {
4372 int64_t allocation_start, host_offset, guest_offset;
4373 int64_t clusters_allocated;
4374 int64_t old_file_size, last_cluster, new_file_size;
4375 uint64_t nb_new_data_clusters, nb_new_l2_tables;
4376 bool subclusters_need_allocation = false;
4377
4378
4379
4380 if (has_data_file(bs)) {
4381 ret = preallocate_co(bs, old_length, offset, prealloc, errp);
4382 if (ret < 0) {
4383 goto fail;
4384 }
4385 break;
4386 }
4387
4388 old_file_size = bdrv_getlength(bs->file->bs);
4389 if (old_file_size < 0) {
4390 error_setg_errno(errp, -old_file_size,
4391 "Failed to inquire current file length");
4392 ret = old_file_size;
4393 goto fail;
4394 }
4395
4396 last_cluster = qcow2_get_last_cluster(bs, old_file_size);
4397 if (last_cluster >= 0) {
4398 old_file_size = (last_cluster + 1) * s->cluster_size;
4399 } else {
4400 old_file_size = ROUND_UP(old_file_size, s->cluster_size);
4401 }
4402
4403 nb_new_data_clusters = (ROUND_UP(offset, s->cluster_size) -
4404 start_of_cluster(s, old_length)) >> s->cluster_bits;
4405
4406
4407
4408
4409
4410
4411
4412
4413
4414
4415
4416 nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters,
4417 s->cluster_size / l2_entry_size(s));
4418
4419
4420 nb_new_l2_tables++;
4421
4422 allocation_start = qcow2_refcount_area(bs, old_file_size,
4423 nb_new_data_clusters +
4424 nb_new_l2_tables,
4425 true, 0, 0);
4426 if (allocation_start < 0) {
4427 error_setg_errno(errp, -allocation_start,
4428 "Failed to resize refcount structures");
4429 ret = allocation_start;
4430 goto fail;
4431 }
4432
4433 clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start,
4434 nb_new_data_clusters);
4435 if (clusters_allocated < 0) {
4436 error_setg_errno(errp, -clusters_allocated,
4437 "Failed to allocate data clusters");
4438 ret = clusters_allocated;
4439 goto fail;
4440 }
4441
4442 assert(clusters_allocated == nb_new_data_clusters);
4443
4444
4445 new_file_size = allocation_start +
4446 nb_new_data_clusters * s->cluster_size;
4447
4448
4449
4450
4451
4452
4453 if (flags & BDRV_REQ_ZERO_WRITE) {
4454 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
4455 BDRV_REQ_ZERO_WRITE, NULL);
4456 if (ret >= 0) {
4457 flags &= ~BDRV_REQ_ZERO_WRITE;
4458
4459 subclusters_need_allocation = true;
4460 }
4461 } else {
4462 ret = -1;
4463 }
4464 if (ret < 0) {
4465 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
4466 errp);
4467 }
4468 if (ret < 0) {
4469 error_prepend(errp, "Failed to resize underlying file: ");
4470 qcow2_free_clusters(bs, allocation_start,
4471 nb_new_data_clusters * s->cluster_size,
4472 QCOW2_DISCARD_OTHER);
4473 goto fail;
4474 }
4475
4476
4477 host_offset = allocation_start;
4478 guest_offset = old_length;
4479 while (nb_new_data_clusters) {
4480 int64_t nb_clusters = MIN(
4481 nb_new_data_clusters,
4482 s->l2_slice_size - offset_to_l2_slice_index(s, guest_offset));
4483 unsigned cow_start_length = offset_into_cluster(s, guest_offset);
4484 QCowL2Meta allocation;
4485 guest_offset = start_of_cluster(s, guest_offset);
4486 allocation = (QCowL2Meta) {
4487 .offset = guest_offset,
4488 .alloc_offset = host_offset,
4489 .nb_clusters = nb_clusters,
4490 .cow_start = {
4491 .offset = 0,
4492 .nb_bytes = cow_start_length,
4493 },
4494 .cow_end = {
4495 .offset = nb_clusters << s->cluster_bits,
4496 .nb_bytes = 0,
4497 },
4498 .prealloc = !subclusters_need_allocation,
4499 };
4500 qemu_co_queue_init(&allocation.dependent_requests);
4501
4502 ret = qcow2_alloc_cluster_link_l2(bs, &allocation);
4503 if (ret < 0) {
4504 error_setg_errno(errp, -ret, "Failed to update L2 tables");
4505 qcow2_free_clusters(bs, host_offset,
4506 nb_new_data_clusters * s->cluster_size,
4507 QCOW2_DISCARD_OTHER);
4508 goto fail;
4509 }
4510
4511 guest_offset += nb_clusters * s->cluster_size;
4512 host_offset += nb_clusters * s->cluster_size;
4513 nb_new_data_clusters -= nb_clusters;
4514 }
4515 break;
4516 }
4517
4518 default:
4519 g_assert_not_reached();
4520 }
4521
4522 if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
4523 uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->subcluster_size);
4524
4525
4526
4527
4528
4529
4530 if (offset > zero_start) {
4531 ret = qcow2_subcluster_zeroize(bs, zero_start, offset - zero_start,
4532 0);
4533 if (ret < 0) {
4534 error_setg_errno(errp, -ret, "Failed to zero out new clusters");
4535 goto fail;
4536 }
4537 }
4538
4539
4540 if (zero_start > old_length) {
4541 uint64_t len = MIN(zero_start, offset) - old_length;
4542 uint8_t *buf = qemu_blockalign0(bs, len);
4543 QEMUIOVector qiov;
4544 qemu_iovec_init_buf(&qiov, buf, len);
4545
4546 qemu_co_mutex_unlock(&s->lock);
4547 ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
4548 qemu_co_mutex_lock(&s->lock);
4549
4550 qemu_vfree(buf);
4551 if (ret < 0) {
4552 error_setg_errno(errp, -ret, "Failed to zero out the new area");
4553 goto fail;
4554 }
4555 }
4556 }
4557
4558 if (prealloc != PREALLOC_MODE_OFF) {
4559
4560 ret = qcow2_write_caches(bs);
4561 if (ret < 0) {
4562 error_setg_errno(errp, -ret,
4563 "Failed to flush the preallocated area to disk");
4564 goto fail;
4565 }
4566 }
4567
4568 bs->total_sectors = offset / BDRV_SECTOR_SIZE;
4569
4570
4571 offset = cpu_to_be64(offset);
4572 ret = bdrv_co_pwrite_sync(bs->file, offsetof(QCowHeader, size),
4573 sizeof(offset), &offset, 0);
4574 if (ret < 0) {
4575 error_setg_errno(errp, -ret, "Failed to update the image size");
4576 goto fail;
4577 }
4578
4579 s->l1_vm_state_index = new_l1_size;
4580
4581
4582 options = qdict_clone_shallow(bs->options);
4583 ret = qcow2_update_options(bs, options, s->flags, errp);
4584 qobject_unref(options);
4585 if (ret < 0) {
4586 goto fail;
4587 }
4588 ret = 0;
4589fail:
4590 qemu_co_mutex_unlock(&s->lock);
4591 return ret;
4592}
4593
4594static int coroutine_fn GRAPH_RDLOCK
4595qcow2_co_pwritev_compressed_task(BlockDriverState *bs,
4596 uint64_t offset, uint64_t bytes,
4597 QEMUIOVector *qiov, size_t qiov_offset)
4598{
4599 BDRVQcow2State *s = bs->opaque;
4600 int ret;
4601 ssize_t out_len;
4602 uint8_t *buf, *out_buf;
4603 uint64_t cluster_offset;
4604
4605 assert(bytes == s->cluster_size || (bytes < s->cluster_size &&
4606 (offset + bytes == bs->total_sectors << BDRV_SECTOR_BITS)));
4607
4608 buf = qemu_blockalign(bs, s->cluster_size);
4609 if (bytes < s->cluster_size) {
4610
4611 memset(buf + bytes, 0, s->cluster_size - bytes);
4612 }
4613 qemu_iovec_to_buf(qiov, qiov_offset, buf, bytes);
4614
4615 out_buf = g_malloc(s->cluster_size);
4616
4617 out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1,
4618 buf, s->cluster_size);
4619 if (out_len == -ENOMEM) {
4620
4621 ret = qcow2_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset, 0);
4622 if (ret < 0) {
4623 goto fail;
4624 }
4625 goto success;
4626 } else if (out_len < 0) {
4627 ret = -EINVAL;
4628 goto fail;
4629 }
4630
4631 qemu_co_mutex_lock(&s->lock);
4632 ret = qcow2_alloc_compressed_cluster_offset(bs, offset, out_len,
4633 &cluster_offset);
4634 if (ret < 0) {
4635 qemu_co_mutex_unlock(&s->lock);
4636 goto fail;
4637 }
4638
4639 ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len, true);
4640 qemu_co_mutex_unlock(&s->lock);
4641 if (ret < 0) {
4642 goto fail;
4643 }
4644
4645 BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
4646 ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);
4647 if (ret < 0) {
4648 goto fail;
4649 }
4650success:
4651 ret = 0;
4652fail:
4653 qemu_vfree(buf);
4654 g_free(out_buf);
4655 return ret;
4656}
4657
4658
4659
4660
4661
4662
4663static int coroutine_fn GRAPH_RDLOCK
4664qcow2_co_pwritev_compressed_task_entry(AioTask *task)
4665{
4666 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
4667
4668 assert(!t->subcluster_type && !t->l2meta);
4669
4670 return qcow2_co_pwritev_compressed_task(t->bs, t->offset, t->bytes, t->qiov,
4671 t->qiov_offset);
4672}
4673
4674
4675
4676
4677
4678static int coroutine_fn GRAPH_RDLOCK
4679qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
4680 int64_t offset, int64_t bytes,
4681 QEMUIOVector *qiov, size_t qiov_offset)
4682{
4683 BDRVQcow2State *s = bs->opaque;
4684 AioTaskPool *aio = NULL;
4685 int ret = 0;
4686
4687 if (has_data_file(bs)) {
4688 return -ENOTSUP;
4689 }
4690
4691 if (bytes == 0) {
4692
4693
4694
4695
4696 int64_t len = bdrv_getlength(bs->file->bs);
4697 if (len < 0) {
4698 return len;
4699 }
4700 return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
4701 NULL);
4702 }
4703
4704 if (offset_into_cluster(s, offset)) {
4705 return -EINVAL;
4706 }
4707
4708 if (offset_into_cluster(s, bytes) &&
4709 (offset + bytes) != (bs->total_sectors << BDRV_SECTOR_BITS)) {
4710 return -EINVAL;
4711 }
4712
4713 while (bytes && aio_task_pool_status(aio) == 0) {
4714 uint64_t chunk_size = MIN(bytes, s->cluster_size);
4715
4716 if (!aio && chunk_size != bytes) {
4717 aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
4718 }
4719
4720 ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_compressed_task_entry,
4721 0, 0, offset, chunk_size, qiov, qiov_offset, NULL);
4722 if (ret < 0) {
4723 break;
4724 }
4725 qiov_offset += chunk_size;
4726 offset += chunk_size;
4727 bytes -= chunk_size;
4728 }
4729
4730 if (aio) {
4731 aio_task_pool_wait_all(aio);
4732 if (ret == 0) {
4733 ret = aio_task_pool_status(aio);
4734 }
4735 g_free(aio);
4736 }
4737
4738 return ret;
4739}
4740
4741static int coroutine_fn GRAPH_RDLOCK
4742qcow2_co_preadv_compressed(BlockDriverState *bs,
4743 uint64_t l2_entry,
4744 uint64_t offset,
4745 uint64_t bytes,
4746 QEMUIOVector *qiov,
4747 size_t qiov_offset)
4748{
4749 BDRVQcow2State *s = bs->opaque;
4750 int ret = 0, csize;
4751 uint64_t coffset;
4752 uint8_t *buf, *out_buf;
4753 int offset_in_cluster = offset_into_cluster(s, offset);
4754
4755 qcow2_parse_compressed_l2_entry(bs, l2_entry, &coffset, &csize);
4756
4757 buf = g_try_malloc(csize);
4758 if (!buf) {
4759 return -ENOMEM;
4760 }
4761
4762 out_buf = qemu_blockalign(bs, s->cluster_size);
4763
4764 BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
4765 ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);
4766 if (ret < 0) {
4767 goto fail;
4768 }
4769
4770 if (qcow2_co_decompress(bs, out_buf, s->cluster_size, buf, csize) < 0) {
4771 ret = -EIO;
4772 goto fail;
4773 }
4774
4775 qemu_iovec_from_buf(qiov, qiov_offset, out_buf + offset_in_cluster, bytes);
4776
4777fail:
4778 qemu_vfree(out_buf);
4779 g_free(buf);
4780
4781 return ret;
4782}
4783
4784static int make_completely_empty(BlockDriverState *bs)
4785{
4786 BDRVQcow2State *s = bs->opaque;
4787 Error *local_err = NULL;
4788 int ret, l1_clusters;
4789 int64_t offset;
4790 uint64_t *new_reftable = NULL;
4791 uint64_t rt_entry, l1_size2;
4792 struct {
4793 uint64_t l1_offset;
4794 uint64_t reftable_offset;
4795 uint32_t reftable_clusters;
4796 } QEMU_PACKED l1_ofs_rt_ofs_cls;
4797
4798 ret = qcow2_cache_empty(bs, s->l2_table_cache);
4799 if (ret < 0) {
4800 goto fail;
4801 }
4802
4803 ret = qcow2_cache_empty(bs, s->refcount_block_cache);
4804 if (ret < 0) {
4805 goto fail;
4806 }
4807
4808
4809 ret = qcow2_mark_dirty(bs);
4810 if (ret < 0) {
4811 goto fail;
4812 }
4813
4814 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4815
4816 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE);
4817 l1_size2 = (uint64_t)s->l1_size * L1E_SIZE;
4818
4819
4820
4821
4822 ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset,
4823 l1_clusters * s->cluster_size, 0);
4824 if (ret < 0) {
4825 goto fail_broken_refcounts;
4826 }
4827 memset(s->l1_table, 0, l1_size2);
4828
4829 BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);
4830
4831
4832
4833
4834
4835
4836 ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size,
4837 (2 + l1_clusters) * s->cluster_size, 0);
4838
4839
4840
4841
4842 if (ret < 0) {
4843 goto fail_broken_refcounts;
4844 }
4845
4846 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4847 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);
4848
4849
4850
4851
4852 l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size);
4853 l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
4854 l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
4855 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
4856 sizeof(l1_ofs_rt_ofs_cls), &l1_ofs_rt_ofs_cls, 0);
4857 if (ret < 0) {
4858 goto fail_broken_refcounts;
4859 }
4860
4861 s->l1_table_offset = 3 * s->cluster_size;
4862
4863 new_reftable = g_try_new0(uint64_t, s->cluster_size / REFTABLE_ENTRY_SIZE);
4864 if (!new_reftable) {
4865 ret = -ENOMEM;
4866 goto fail_broken_refcounts;
4867 }
4868
4869 s->refcount_table_offset = s->cluster_size;
4870 s->refcount_table_size = s->cluster_size / REFTABLE_ENTRY_SIZE;
4871 s->max_refcount_table_index = 0;
4872
4873 g_free(s->refcount_table);
4874 s->refcount_table = new_reftable;
4875 new_reftable = NULL;
4876
4877
4878
4879
4880
4881
4882
4883 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
4884
4885
4886 rt_entry = cpu_to_be64(2 * s->cluster_size);
4887 ret = bdrv_pwrite_sync(bs->file, s->cluster_size, sizeof(rt_entry),
4888 &rt_entry, 0);
4889 if (ret < 0) {
4890 goto fail_broken_refcounts;
4891 }
4892 s->refcount_table[0] = 2 * s->cluster_size;
4893
4894 s->free_cluster_index = 0;
4895 assert(3 + l1_clusters <= s->refcount_block_size);
4896 offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2);
4897 if (offset < 0) {
4898 ret = offset;
4899 goto fail_broken_refcounts;
4900 } else if (offset > 0) {
4901 error_report("First cluster in emptied image is in use");
4902 abort();
4903 }
4904
4905
4906
4907 ret = qcow2_mark_clean(bs);
4908 if (ret < 0) {
4909 goto fail;
4910 }
4911
4912 ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
4913 PREALLOC_MODE_OFF, 0, &local_err);
4914 if (ret < 0) {
4915 error_report_err(local_err);
4916 goto fail;
4917 }
4918
4919 return 0;
4920
4921fail_broken_refcounts:
4922
4923
4924
4925
4926
4927
4928 bs->drv = NULL;
4929
4930fail:
4931 g_free(new_reftable);
4932 return ret;
4933}
4934
4935static int qcow2_make_empty(BlockDriverState *bs)
4936{
4937 BDRVQcow2State *s = bs->opaque;
4938 uint64_t offset, end_offset;
4939 int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size);
4940 int l1_clusters, ret = 0;
4941
4942 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE);
4943
4944 if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps &&
4945 3 + l1_clusters <= s->refcount_block_size &&
4946 s->crypt_method_header != QCOW_CRYPT_LUKS &&
4947 !has_data_file(bs)) {
4948
4949
4950
4951
4952
4953
4954
4955
4956
4957 return make_completely_empty(bs);
4958 }
4959
4960
4961
4962 end_offset = bs->total_sectors * BDRV_SECTOR_SIZE;
4963 for (offset = 0; offset < end_offset; offset += step) {
4964
4965
4966
4967
4968
4969 ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset),
4970 QCOW2_DISCARD_SNAPSHOT, true);
4971 if (ret < 0) {
4972 break;
4973 }
4974 }
4975
4976 return ret;
4977}
4978
4979static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
4980{
4981 BDRVQcow2State *s = bs->opaque;
4982 int ret;
4983
4984 qemu_co_mutex_lock(&s->lock);
4985 ret = qcow2_write_caches(bs);
4986 qemu_co_mutex_unlock(&s->lock);
4987
4988 return ret;
4989}
4990
4991static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
4992 Error **errp)
4993{
4994 Error *local_err = NULL;
4995 BlockMeasureInfo *info;
4996 uint64_t required = 0;
4997 uint64_t virtual_size;
4998 uint64_t refcount_bits;
4999 uint64_t l2_tables;
5000 uint64_t luks_payload_size = 0;
5001 size_t cluster_size;
5002 int version;
5003 char *optstr;
5004 PreallocMode prealloc;
5005 bool has_backing_file;
5006 bool has_luks;
5007 bool extended_l2;
5008 size_t l2e_size;
5009
5010
5011 extended_l2 = qemu_opt_get_bool_del(opts, BLOCK_OPT_EXTL2, false);
5012
5013 cluster_size = qcow2_opt_get_cluster_size_del(opts, extended_l2,
5014 &local_err);
5015 if (local_err) {
5016 goto err;
5017 }
5018
5019 version = qcow2_opt_get_version_del(opts, &local_err);
5020 if (local_err) {
5021 goto err;
5022 }
5023
5024 refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
5025 if (local_err) {
5026 goto err;
5027 }
5028
5029 optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
5030 prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr,
5031 PREALLOC_MODE_OFF, &local_err);
5032 g_free(optstr);
5033 if (local_err) {
5034 goto err;
5035 }
5036
5037 optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
5038 has_backing_file = !!optstr;
5039 g_free(optstr);
5040
5041 optstr = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
5042 has_luks = optstr && strcmp(optstr, "luks") == 0;
5043 g_free(optstr);
5044
5045 if (has_luks) {
5046 g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
5047 QDict *cryptoopts = qcow2_extract_crypto_opts(opts, "luks", errp);
5048 size_t headerlen;
5049
5050 create_opts = block_crypto_create_opts_init(cryptoopts, errp);
5051 qobject_unref(cryptoopts);
5052 if (!create_opts) {
5053 goto err;
5054 }
5055
5056 if (!qcrypto_block_calculate_payload_offset(create_opts,
5057 "encrypt.",
5058 &headerlen,
5059 &local_err)) {
5060 goto err;
5061 }
5062
5063 luks_payload_size = ROUND_UP(headerlen, cluster_size);
5064 }
5065
5066 virtual_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
5067 virtual_size = ROUND_UP(virtual_size, cluster_size);
5068
5069
5070 l2e_size = extended_l2 ? L2E_SIZE_EXTENDED : L2E_SIZE_NORMAL;
5071 l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
5072 cluster_size / l2e_size);
5073 if (l2_tables * L1E_SIZE > QCOW_MAX_L1_SIZE) {
5074 error_setg(&local_err, "The image size is too large "
5075 "(try using a larger cluster size)");
5076 goto err;
5077 }
5078
5079
5080 if (in_bs) {
5081 int64_t ssize = bdrv_getlength(in_bs);
5082 if (ssize < 0) {
5083 error_setg_errno(&local_err, -ssize,
5084 "Unable to get image virtual_size");
5085 goto err;
5086 }
5087
5088 virtual_size = ROUND_UP(ssize, cluster_size);
5089
5090 if (has_backing_file) {
5091
5092
5093
5094
5095
5096 required = virtual_size;
5097 } else {
5098 int64_t offset;
5099 int64_t pnum = 0;
5100
5101 for (offset = 0; offset < ssize; offset += pnum) {
5102 int ret;
5103
5104 ret = bdrv_block_status_above(in_bs, NULL, offset,
5105 ssize - offset, &pnum, NULL,
5106 NULL);
5107 if (ret < 0) {
5108 error_setg_errno(&local_err, -ret,
5109 "Unable to get block status");
5110 goto err;
5111 }
5112
5113 if (ret & BDRV_BLOCK_ZERO) {
5114
5115 } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
5116 (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
5117
5118 pnum = ROUND_UP(offset + pnum, cluster_size) - offset;
5119
5120
5121 required += offset % cluster_size + pnum;
5122 }
5123 }
5124 }
5125 }
5126
5127
5128
5129
5130 if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
5131 required = virtual_size;
5132 }
5133
5134 info = g_new0(BlockMeasureInfo, 1);
5135 info->fully_allocated = luks_payload_size +
5136 qcow2_calc_prealloc_size(virtual_size, cluster_size,
5137 ctz32(refcount_bits), extended_l2);
5138
5139
5140
5141
5142
5143
5144
5145 info->required = info->fully_allocated - virtual_size + required;
5146 info->has_bitmaps = version >= 3 && in_bs &&
5147 bdrv_supports_persistent_dirty_bitmap(in_bs);
5148 if (info->has_bitmaps) {
5149 info->bitmaps = qcow2_get_persistent_dirty_bitmap_size(in_bs,
5150 cluster_size);
5151 }
5152 return info;
5153
5154err:
5155 error_propagate(errp, local_err);
5156 return NULL;
5157}
5158
5159static int coroutine_fn
5160qcow2_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
5161{
5162 BDRVQcow2State *s = bs->opaque;
5163 bdi->cluster_size = s->cluster_size;
5164 bdi->vm_state_offset = qcow2_vm_state_offset(s);
5165 bdi->is_dirty = s->incompatible_features & QCOW2_INCOMPAT_DIRTY;
5166 return 0;
5167}
5168
5169static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
5170 Error **errp)
5171{
5172 BDRVQcow2State *s = bs->opaque;
5173 ImageInfoSpecific *spec_info;
5174 QCryptoBlockInfo *encrypt_info = NULL;
5175
5176 if (s->crypto != NULL) {
5177 encrypt_info = qcrypto_block_get_info(s->crypto, errp);
5178 if (!encrypt_info) {
5179 return NULL;
5180 }
5181 }
5182
5183 spec_info = g_new(ImageInfoSpecific, 1);
5184 *spec_info = (ImageInfoSpecific){
5185 .type = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
5186 .u.qcow2.data = g_new0(ImageInfoSpecificQCow2, 1),
5187 };
5188 if (s->qcow_version == 2) {
5189 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
5190 .compat = g_strdup("0.10"),
5191 .refcount_bits = s->refcount_bits,
5192 };
5193 } else if (s->qcow_version == 3) {
5194 Qcow2BitmapInfoList *bitmaps;
5195 if (!qcow2_get_bitmap_info_list(bs, &bitmaps, errp)) {
5196 qapi_free_ImageInfoSpecific(spec_info);
5197 qapi_free_QCryptoBlockInfo(encrypt_info);
5198 return NULL;
5199 }
5200 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
5201 .compat = g_strdup("1.1"),
5202 .lazy_refcounts = s->compatible_features &
5203 QCOW2_COMPAT_LAZY_REFCOUNTS,
5204 .has_lazy_refcounts = true,
5205 .corrupt = s->incompatible_features &
5206 QCOW2_INCOMPAT_CORRUPT,
5207 .has_corrupt = true,
5208 .has_extended_l2 = true,
5209 .extended_l2 = has_subclusters(s),
5210 .refcount_bits = s->refcount_bits,
5211 .has_bitmaps = !!bitmaps,
5212 .bitmaps = bitmaps,
5213 .data_file = g_strdup(s->image_data_file),
5214 .has_data_file_raw = has_data_file(bs),
5215 .data_file_raw = data_file_is_raw(bs),
5216 .compression_type = s->compression_type,
5217 };
5218 } else {
5219
5220
5221 assert(false);
5222 }
5223
5224 if (encrypt_info) {
5225 ImageInfoSpecificQCow2Encryption *qencrypt =
5226 g_new(ImageInfoSpecificQCow2Encryption, 1);
5227 switch (encrypt_info->format) {
5228 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
5229 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES;
5230 break;
5231 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
5232 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS;
5233 qencrypt->u.luks = encrypt_info->u.luks;
5234 break;
5235 default:
5236 abort();
5237 }
5238
5239
5240 memset(&encrypt_info->u, 0, sizeof(encrypt_info->u));
5241 qapi_free_QCryptoBlockInfo(encrypt_info);
5242
5243 spec_info->u.qcow2.data->encrypt = qencrypt;
5244 }
5245
5246 return spec_info;
5247}
5248
5249static int qcow2_has_zero_init(BlockDriverState *bs)
5250{
5251 BDRVQcow2State *s = bs->opaque;
5252 bool preallocated;
5253
5254 if (qemu_in_coroutine()) {
5255 qemu_co_mutex_lock(&s->lock);
5256 }
5257
5258
5259
5260
5261
5262 preallocated = s->l1_size > 0 && s->l1_table[0] != 0;
5263 if (qemu_in_coroutine()) {
5264 qemu_co_mutex_unlock(&s->lock);
5265 }
5266
5267 if (!preallocated) {
5268 return 1;
5269 } else if (bs->encrypted) {
5270 return 0;
5271 } else {
5272 return bdrv_has_zero_init(s->data_file->bs);
5273 }
5274}
5275
5276
5277
5278
5279
5280static int64_t qcow2_check_vmstate_request(BlockDriverState *bs,
5281 QEMUIOVector *qiov, int64_t pos)
5282{
5283 BDRVQcow2State *s = bs->opaque;
5284 int64_t vmstate_offset = qcow2_vm_state_offset(s);
5285 int ret;
5286
5287
5288 bdrv_check_qiov_request(pos, qiov->size, qiov, 0, &error_abort);
5289
5290 if (INT64_MAX - pos < vmstate_offset) {
5291 return -EIO;
5292 }
5293
5294 pos += vmstate_offset;
5295 ret = bdrv_check_qiov_request(pos, qiov->size, qiov, 0, NULL);
5296 if (ret < 0) {
5297 return ret;
5298 }
5299
5300 return pos;
5301}
5302
5303static int coroutine_fn GRAPH_RDLOCK
5304qcow2_co_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
5305{
5306 int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
5307 if (offset < 0) {
5308 return offset;
5309 }
5310
5311 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
5312 return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0);
5313}
5314
5315static int coroutine_fn GRAPH_RDLOCK
5316qcow2_co_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
5317{
5318 int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
5319 if (offset < 0) {
5320 return offset;
5321 }
5322
5323 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
5324 return bs->drv->bdrv_co_preadv_part(bs, offset, qiov->size, qiov, 0, 0);
5325}
5326
5327static int qcow2_has_compressed_clusters(BlockDriverState *bs)
5328{
5329 int64_t offset = 0;
5330 int64_t bytes = bdrv_getlength(bs);
5331
5332 if (bytes < 0) {
5333 return bytes;
5334 }
5335
5336 while (bytes != 0) {
5337 int ret;
5338 QCow2SubclusterType type;
5339 unsigned int cur_bytes = MIN(INT_MAX, bytes);
5340 uint64_t host_offset;
5341
5342 ret = qcow2_get_host_offset(bs, offset, &cur_bytes, &host_offset,
5343 &type);
5344 if (ret < 0) {
5345 return ret;
5346 }
5347
5348 if (type == QCOW2_SUBCLUSTER_COMPRESSED) {
5349 return 1;
5350 }
5351
5352 offset += cur_bytes;
5353 bytes -= cur_bytes;
5354 }
5355
5356 return 0;
5357}
5358
5359
5360
5361
5362
5363static int qcow2_downgrade(BlockDriverState *bs, int target_version,
5364 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5365 Error **errp)
5366{
5367 BDRVQcow2State *s = bs->opaque;
5368 int current_version = s->qcow_version;
5369 int ret;
5370 int i;
5371
5372
5373 assert(target_version < current_version);
5374
5375
5376 assert(target_version == 2);
5377
5378 if (s->refcount_order != 4) {
5379 error_setg(errp, "compat=0.10 requires refcount_bits=16");
5380 return -ENOTSUP;
5381 }
5382
5383 if (has_data_file(bs)) {
5384 error_setg(errp, "Cannot downgrade an image with a data file");
5385 return -ENOTSUP;
5386 }
5387
5388
5389
5390
5391
5392
5393
5394
5395 for (i = 0; i < s->nb_snapshots; i++) {
5396 if (s->snapshots[i].vm_state_size > UINT32_MAX ||
5397 s->snapshots[i].disk_size != bs->total_sectors * BDRV_SECTOR_SIZE) {
5398 error_setg(errp, "Internal snapshots prevent downgrade of image");
5399 return -ENOTSUP;
5400 }
5401 }
5402
5403
5404 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
5405 ret = qcow2_mark_clean(bs);
5406 if (ret < 0) {
5407 error_setg_errno(errp, -ret, "Failed to make the image clean");
5408 return ret;
5409 }
5410 }
5411
5412
5413
5414
5415
5416 if (s->incompatible_features & ~QCOW2_INCOMPAT_COMPRESSION) {
5417 error_setg(errp, "Cannot downgrade an image with incompatible features "
5418 "0x%" PRIx64 " set",
5419 s->incompatible_features & ~QCOW2_INCOMPAT_COMPRESSION);
5420 return -ENOTSUP;
5421 }
5422
5423
5424 s->compatible_features = 0;
5425
5426
5427
5428
5429 s->autoclear_features = 0;
5430
5431 ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque);
5432 if (ret < 0) {
5433 error_setg_errno(errp, -ret, "Failed to turn zero into data clusters");
5434 return ret;
5435 }
5436
5437 if (s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION) {
5438 ret = qcow2_has_compressed_clusters(bs);
5439 if (ret < 0) {
5440 error_setg(errp, "Failed to check block status");
5441 return -EINVAL;
5442 }
5443 if (ret) {
5444 error_setg(errp, "Cannot downgrade an image with zstd compression "
5445 "type and existing compressed clusters");
5446 return -ENOTSUP;
5447 }
5448
5449
5450
5451
5452 s->incompatible_features &= ~QCOW2_INCOMPAT_COMPRESSION;
5453 s->compression_type = QCOW2_COMPRESSION_TYPE_ZLIB;
5454 }
5455
5456 assert(s->incompatible_features == 0);
5457
5458 s->qcow_version = target_version;
5459 ret = qcow2_update_header(bs);
5460 if (ret < 0) {
5461 s->qcow_version = current_version;
5462 error_setg_errno(errp, -ret, "Failed to update the image header");
5463 return ret;
5464 }
5465 return 0;
5466}
5467
5468
5469
5470
5471
5472
5473static int qcow2_upgrade(BlockDriverState *bs, int target_version,
5474 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5475 Error **errp)
5476{
5477 BDRVQcow2State *s = bs->opaque;
5478 bool need_snapshot_update;
5479 int current_version = s->qcow_version;
5480 int i;
5481 int ret;
5482
5483
5484 assert(target_version > current_version);
5485
5486
5487 assert(target_version == 3);
5488
5489 status_cb(bs, 0, 2, cb_opaque);
5490
5491
5492
5493
5494
5495
5496
5497
5498 need_snapshot_update = false;
5499 for (i = 0; i < s->nb_snapshots; i++) {
5500 if (s->snapshots[i].extra_data_size <
5501 sizeof_field(QCowSnapshotExtraData, vm_state_size_large) +
5502 sizeof_field(QCowSnapshotExtraData, disk_size))
5503 {
5504 need_snapshot_update = true;
5505 break;
5506 }
5507 }
5508 if (need_snapshot_update) {
5509 ret = qcow2_write_snapshots(bs);
5510 if (ret < 0) {
5511 error_setg_errno(errp, -ret, "Failed to update the snapshot table");
5512 return ret;
5513 }
5514 }
5515 status_cb(bs, 1, 2, cb_opaque);
5516
5517 s->qcow_version = target_version;
5518 ret = qcow2_update_header(bs);
5519 if (ret < 0) {
5520 s->qcow_version = current_version;
5521 error_setg_errno(errp, -ret, "Failed to update the image header");
5522 return ret;
5523 }
5524 status_cb(bs, 2, 2, cb_opaque);
5525
5526 return 0;
5527}
5528
5529typedef enum Qcow2AmendOperation {
5530
5531
5532
5533 QCOW2_NO_OPERATION = 0,
5534
5535 QCOW2_UPGRADING,
5536 QCOW2_UPDATING_ENCRYPTION,
5537 QCOW2_CHANGING_REFCOUNT_ORDER,
5538 QCOW2_DOWNGRADING,
5539} Qcow2AmendOperation;
5540
5541typedef struct Qcow2AmendHelperCBInfo {
5542
5543
5544 BlockDriverAmendStatusCB *original_status_cb;
5545 void *original_cb_opaque;
5546
5547 Qcow2AmendOperation current_operation;
5548
5549
5550 int total_operations;
5551
5552
5553
5554
5555 int operations_completed;
5556
5557
5558 int64_t offset_completed;
5559
5560 Qcow2AmendOperation last_operation;
5561 int64_t last_work_size;
5562} Qcow2AmendHelperCBInfo;
5563
5564static void qcow2_amend_helper_cb(BlockDriverState *bs,
5565 int64_t operation_offset,
5566 int64_t operation_work_size, void *opaque)
5567{
5568 Qcow2AmendHelperCBInfo *info = opaque;
5569 int64_t current_work_size;
5570 int64_t projected_work_size;
5571
5572 if (info->current_operation != info->last_operation) {
5573 if (info->last_operation != QCOW2_NO_OPERATION) {
5574 info->offset_completed += info->last_work_size;
5575 info->operations_completed++;
5576 }
5577
5578 info->last_operation = info->current_operation;
5579 }
5580
5581 assert(info->total_operations > 0);
5582 assert(info->operations_completed < info->total_operations);
5583
5584 info->last_work_size = operation_work_size;
5585
5586 current_work_size = info->offset_completed + operation_work_size;
5587
5588
5589
5590
5591
5592 projected_work_size = current_work_size * (info->total_operations -
5593 info->operations_completed - 1)
5594 / (info->operations_completed + 1);
5595
5596 info->original_status_cb(bs, info->offset_completed + operation_offset,
5597 current_work_size + projected_work_size,
5598 info->original_cb_opaque);
5599}
5600
5601static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
5602 BlockDriverAmendStatusCB *status_cb,
5603 void *cb_opaque,
5604 bool force,
5605 Error **errp)
5606{
5607 BDRVQcow2State *s = bs->opaque;
5608 int old_version = s->qcow_version, new_version = old_version;
5609 uint64_t new_size = 0;
5610 const char *backing_file = NULL, *backing_format = NULL, *data_file = NULL;
5611 bool lazy_refcounts = s->use_lazy_refcounts;
5612 bool data_file_raw = data_file_is_raw(bs);
5613 const char *compat = NULL;
5614 int refcount_bits = s->refcount_bits;
5615 int ret;
5616 QemuOptDesc *desc = opts->list->desc;
5617 Qcow2AmendHelperCBInfo helper_cb_info;
5618 bool encryption_update = false;
5619
5620 while (desc && desc->name) {
5621 if (!qemu_opt_find(opts, desc->name)) {
5622
5623 desc++;
5624 continue;
5625 }
5626
5627 if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
5628 compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
5629 if (!compat) {
5630
5631 } else if (!strcmp(compat, "0.10") || !strcmp(compat, "v2")) {
5632 new_version = 2;
5633 } else if (!strcmp(compat, "1.1") || !strcmp(compat, "v3")) {
5634 new_version = 3;
5635 } else {
5636 error_setg(errp, "Unknown compatibility level %s", compat);
5637 return -EINVAL;
5638 }
5639 } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) {
5640 new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5641 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) {
5642 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5643 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) {
5644 backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5645 } else if (g_str_has_prefix(desc->name, "encrypt.")) {
5646 if (!s->crypto) {
5647 error_setg(errp,
5648 "Can't amend encryption options - encryption not present");
5649 return -EINVAL;
5650 }
5651 if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
5652 error_setg(errp,
5653 "Only LUKS encryption options can be amended");
5654 return -ENOTSUP;
5655 }
5656 encryption_update = true;
5657 } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
5658 lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
5659 lazy_refcounts);
5660 } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
5661 refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS,
5662 refcount_bits);
5663
5664 if (refcount_bits <= 0 || refcount_bits > 64 ||
5665 !is_power_of_2(refcount_bits))
5666 {
5667 error_setg(errp, "Refcount width must be a power of two and "
5668 "may not exceed 64 bits");
5669 return -EINVAL;
5670 }
5671 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE)) {
5672 data_file = qemu_opt_get(opts, BLOCK_OPT_DATA_FILE);
5673 if (data_file && !has_data_file(bs)) {
5674 error_setg(errp, "data-file can only be set for images that "
5675 "use an external data file");
5676 return -EINVAL;
5677 }
5678 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE_RAW)) {
5679 data_file_raw = qemu_opt_get_bool(opts, BLOCK_OPT_DATA_FILE_RAW,
5680 data_file_raw);
5681 if (data_file_raw && !data_file_is_raw(bs)) {
5682 error_setg(errp, "data-file-raw cannot be set on existing "
5683 "images");
5684 return -EINVAL;
5685 }
5686 } else {
5687
5688
5689 abort();
5690 }
5691
5692 desc++;
5693 }
5694
5695 helper_cb_info = (Qcow2AmendHelperCBInfo){
5696 .original_status_cb = status_cb,
5697 .original_cb_opaque = cb_opaque,
5698 .total_operations = (new_version != old_version)
5699 + (s->refcount_bits != refcount_bits) +
5700 (encryption_update == true)
5701 };
5702
5703
5704 if (new_version > old_version) {
5705 helper_cb_info.current_operation = QCOW2_UPGRADING;
5706 ret = qcow2_upgrade(bs, new_version, &qcow2_amend_helper_cb,
5707 &helper_cb_info, errp);
5708 if (ret < 0) {
5709 return ret;
5710 }
5711 }
5712
5713 if (encryption_update) {
5714 QDict *amend_opts_dict;
5715 QCryptoBlockAmendOptions *amend_opts;
5716
5717 helper_cb_info.current_operation = QCOW2_UPDATING_ENCRYPTION;
5718 amend_opts_dict = qcow2_extract_crypto_opts(opts, "luks", errp);
5719 if (!amend_opts_dict) {
5720 return -EINVAL;
5721 }
5722 amend_opts = block_crypto_amend_opts_init(amend_opts_dict, errp);
5723 qobject_unref(amend_opts_dict);
5724 if (!amend_opts) {
5725 return -EINVAL;
5726 }
5727 ret = qcrypto_block_amend_options(s->crypto,
5728 qcow2_crypto_hdr_read_func,
5729 qcow2_crypto_hdr_write_func,
5730 bs,
5731 amend_opts,
5732 force,
5733 errp);
5734 qapi_free_QCryptoBlockAmendOptions(amend_opts);
5735 if (ret < 0) {
5736 return ret;
5737 }
5738 }
5739
5740 if (s->refcount_bits != refcount_bits) {
5741 int refcount_order = ctz32(refcount_bits);
5742
5743 if (new_version < 3 && refcount_bits != 16) {
5744 error_setg(errp, "Refcount widths other than 16 bits require "
5745 "compatibility level 1.1 or above (use compat=1.1 or "
5746 "greater)");
5747 return -EINVAL;
5748 }
5749
5750 helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER;
5751 ret = qcow2_change_refcount_order(bs, refcount_order,
5752 &qcow2_amend_helper_cb,
5753 &helper_cb_info, errp);
5754 if (ret < 0) {
5755 return ret;
5756 }
5757 }
5758
5759
5760 if (data_file_raw) {
5761 s->autoclear_features |= QCOW2_AUTOCLEAR_DATA_FILE_RAW;
5762 } else {
5763 s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW;
5764 }
5765
5766 if (data_file) {
5767 g_free(s->image_data_file);
5768 s->image_data_file = *data_file ? g_strdup(data_file) : NULL;
5769 }
5770
5771 ret = qcow2_update_header(bs);
5772 if (ret < 0) {
5773 error_setg_errno(errp, -ret, "Failed to update the image header");
5774 return ret;
5775 }
5776
5777 if (backing_file || backing_format) {
5778 if (g_strcmp0(backing_file, s->image_backing_file) ||
5779 g_strcmp0(backing_format, s->image_backing_format)) {
5780 error_setg(errp, "Cannot amend the backing file");
5781 error_append_hint(errp,
5782 "You can use 'qemu-img rebase' instead.\n");
5783 return -EINVAL;
5784 }
5785 }
5786
5787 if (s->use_lazy_refcounts != lazy_refcounts) {
5788 if (lazy_refcounts) {
5789 if (new_version < 3) {
5790 error_setg(errp, "Lazy refcounts only supported with "
5791 "compatibility level 1.1 and above (use compat=1.1 "
5792 "or greater)");
5793 return -EINVAL;
5794 }
5795 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
5796 ret = qcow2_update_header(bs);
5797 if (ret < 0) {
5798 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
5799 error_setg_errno(errp, -ret, "Failed to update the image header");
5800 return ret;
5801 }
5802 s->use_lazy_refcounts = true;
5803 } else {
5804
5805 ret = qcow2_mark_clean(bs);
5806 if (ret < 0) {
5807 error_setg_errno(errp, -ret, "Failed to make the image clean");
5808 return ret;
5809 }
5810
5811 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
5812 ret = qcow2_update_header(bs);
5813 if (ret < 0) {
5814 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
5815 error_setg_errno(errp, -ret, "Failed to update the image header");
5816 return ret;
5817 }
5818 s->use_lazy_refcounts = false;
5819 }
5820 }
5821
5822 if (new_size) {
5823 BlockBackend *blk = blk_new_with_bs(bs, BLK_PERM_RESIZE, BLK_PERM_ALL,
5824 errp);
5825 if (!blk) {
5826 return -EPERM;
5827 }
5828
5829
5830
5831
5832
5833 ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
5834 blk_unref(blk);
5835 if (ret < 0) {
5836 return ret;
5837 }
5838 }
5839
5840
5841 if (new_version < old_version) {
5842 helper_cb_info.current_operation = QCOW2_DOWNGRADING;
5843 ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb,
5844 &helper_cb_info, errp);
5845 if (ret < 0) {
5846 return ret;
5847 }
5848 }
5849
5850 return 0;
5851}
5852
5853static int coroutine_fn qcow2_co_amend(BlockDriverState *bs,
5854 BlockdevAmendOptions *opts,
5855 bool force,
5856 Error **errp)
5857{
5858 BlockdevAmendOptionsQcow2 *qopts = &opts->u.qcow2;
5859 BDRVQcow2State *s = bs->opaque;
5860 int ret = 0;
5861
5862 if (qopts->encrypt) {
5863 if (!s->crypto) {
5864 error_setg(errp, "image is not encrypted, can't amend");
5865 return -EOPNOTSUPP;
5866 }
5867
5868 if (qopts->encrypt->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
5869 error_setg(errp,
5870 "Amend can't be used to change the qcow2 encryption format");
5871 return -EOPNOTSUPP;
5872 }
5873
5874 if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
5875 error_setg(errp,
5876 "Only LUKS encryption options can be amended for qcow2 with blockdev-amend");
5877 return -EOPNOTSUPP;
5878 }
5879
5880 ret = qcrypto_block_amend_options(s->crypto,
5881 qcow2_crypto_hdr_read_func,
5882 qcow2_crypto_hdr_write_func,
5883 bs,
5884 qopts->encrypt,
5885 force,
5886 errp);
5887 }
5888 return ret;
5889}
5890
5891
5892
5893
5894
5895
5896
5897void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
5898 int64_t size, const char *message_format, ...)
5899{
5900 BDRVQcow2State *s = bs->opaque;
5901 const char *node_name;
5902 char *message;
5903 va_list ap;
5904
5905 fatal = fatal && bdrv_is_writable(bs);
5906
5907 if (s->signaled_corruption &&
5908 (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT)))
5909 {
5910 return;
5911 }
5912
5913 va_start(ap, message_format);
5914 message = g_strdup_vprintf(message_format, ap);
5915 va_end(ap);
5916
5917 if (fatal) {
5918 fprintf(stderr, "qcow2: Marking image as corrupt: %s; further "
5919 "corruption events will be suppressed\n", message);
5920 } else {
5921 fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal "
5922 "corruption events will be suppressed\n", message);
5923 }
5924
5925 node_name = bdrv_get_node_name(bs);
5926 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
5927 *node_name ? node_name : NULL,
5928 message, offset >= 0, offset,
5929 size >= 0, size,
5930 fatal);
5931 g_free(message);
5932
5933 if (fatal) {
5934 qcow2_mark_corrupt(bs);
5935 bs->drv = NULL;
5936 }
5937
5938 s->signaled_corruption = true;
5939}
5940
5941#define QCOW_COMMON_OPTIONS \
5942 { \
5943 .name = BLOCK_OPT_SIZE, \
5944 .type = QEMU_OPT_SIZE, \
5945 .help = "Virtual disk size" \
5946 }, \
5947 { \
5948 .name = BLOCK_OPT_COMPAT_LEVEL, \
5949 .type = QEMU_OPT_STRING, \
5950 .help = "Compatibility level (v2 [0.10] or v3 [1.1])" \
5951 }, \
5952 { \
5953 .name = BLOCK_OPT_BACKING_FILE, \
5954 .type = QEMU_OPT_STRING, \
5955 .help = "File name of a base image" \
5956 }, \
5957 { \
5958 .name = BLOCK_OPT_BACKING_FMT, \
5959 .type = QEMU_OPT_STRING, \
5960 .help = "Image format of the base image" \
5961 }, \
5962 { \
5963 .name = BLOCK_OPT_DATA_FILE, \
5964 .type = QEMU_OPT_STRING, \
5965 .help = "File name of an external data file" \
5966 }, \
5967 { \
5968 .name = BLOCK_OPT_DATA_FILE_RAW, \
5969 .type = QEMU_OPT_BOOL, \
5970 .help = "The external data file must stay valid " \
5971 "as a raw image" \
5972 }, \
5973 { \
5974 .name = BLOCK_OPT_LAZY_REFCOUNTS, \
5975 .type = QEMU_OPT_BOOL, \
5976 .help = "Postpone refcount updates", \
5977 .def_value_str = "off" \
5978 }, \
5979 { \
5980 .name = BLOCK_OPT_REFCOUNT_BITS, \
5981 .type = QEMU_OPT_NUMBER, \
5982 .help = "Width of a reference count entry in bits", \
5983 .def_value_str = "16" \
5984 }
5985
5986static QemuOptsList qcow2_create_opts = {
5987 .name = "qcow2-create-opts",
5988 .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
5989 .desc = {
5990 { \
5991 .name = BLOCK_OPT_ENCRYPT, \
5992 .type = QEMU_OPT_BOOL, \
5993 .help = "Encrypt the image with format 'aes'. (Deprecated " \
5994 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)", \
5995 }, \
5996 { \
5997 .name = BLOCK_OPT_ENCRYPT_FORMAT, \
5998 .type = QEMU_OPT_STRING, \
5999 .help = "Encrypt the image, format choices: 'aes', 'luks'", \
6000 }, \
6001 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", \
6002 "ID of secret providing qcow AES key or LUKS passphrase"), \
6003 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."), \
6004 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."), \
6005 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."), \
6006 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."), \
6007 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."), \
6008 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."), \
6009 { \
6010 .name = BLOCK_OPT_CLUSTER_SIZE, \
6011 .type = QEMU_OPT_SIZE, \
6012 .help = "qcow2 cluster size", \
6013 .def_value_str = stringify(DEFAULT_CLUSTER_SIZE) \
6014 }, \
6015 { \
6016 .name = BLOCK_OPT_EXTL2, \
6017 .type = QEMU_OPT_BOOL, \
6018 .help = "Extended L2 tables", \
6019 .def_value_str = "off" \
6020 }, \
6021 { \
6022 .name = BLOCK_OPT_PREALLOC, \
6023 .type = QEMU_OPT_STRING, \
6024 .help = "Preallocation mode (allowed values: off, " \
6025 "metadata, falloc, full)" \
6026 }, \
6027 { \
6028 .name = BLOCK_OPT_COMPRESSION_TYPE, \
6029 .type = QEMU_OPT_STRING, \
6030 .help = "Compression method used for image cluster " \
6031 "compression", \
6032 .def_value_str = "zlib" \
6033 },
6034 QCOW_COMMON_OPTIONS,
6035 { }
6036 }
6037};
6038
6039static QemuOptsList qcow2_amend_opts = {
6040 .name = "qcow2-amend-opts",
6041 .head = QTAILQ_HEAD_INITIALIZER(qcow2_amend_opts.head),
6042 .desc = {
6043 BLOCK_CRYPTO_OPT_DEF_LUKS_STATE("encrypt."),
6044 BLOCK_CRYPTO_OPT_DEF_LUKS_KEYSLOT("encrypt."),
6045 BLOCK_CRYPTO_OPT_DEF_LUKS_OLD_SECRET("encrypt."),
6046 BLOCK_CRYPTO_OPT_DEF_LUKS_NEW_SECRET("encrypt."),
6047 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
6048 QCOW_COMMON_OPTIONS,
6049 { }
6050 }
6051};
6052
6053static const char *const qcow2_strong_runtime_opts[] = {
6054 "encrypt." BLOCK_CRYPTO_OPT_QCOW_KEY_SECRET,
6055
6056 NULL
6057};
6058
6059BlockDriver bdrv_qcow2 = {
6060 .format_name = "qcow2",
6061 .instance_size = sizeof(BDRVQcow2State),
6062 .bdrv_probe = qcow2_probe,
6063 .bdrv_open = qcow2_open,
6064 .bdrv_close = qcow2_close,
6065 .bdrv_reopen_prepare = qcow2_reopen_prepare,
6066 .bdrv_reopen_commit = qcow2_reopen_commit,
6067 .bdrv_reopen_commit_post = qcow2_reopen_commit_post,
6068 .bdrv_reopen_abort = qcow2_reopen_abort,
6069 .bdrv_join_options = qcow2_join_options,
6070 .bdrv_child_perm = bdrv_default_perms,
6071 .bdrv_co_create_opts = qcow2_co_create_opts,
6072 .bdrv_co_create = qcow2_co_create,
6073 .bdrv_has_zero_init = qcow2_has_zero_init,
6074 .bdrv_co_block_status = qcow2_co_block_status,
6075
6076 .bdrv_co_preadv_part = qcow2_co_preadv_part,
6077 .bdrv_co_pwritev_part = qcow2_co_pwritev_part,
6078 .bdrv_co_flush_to_os = qcow2_co_flush_to_os,
6079
6080 .bdrv_co_pwrite_zeroes = qcow2_co_pwrite_zeroes,
6081 .bdrv_co_pdiscard = qcow2_co_pdiscard,
6082 .bdrv_co_copy_range_from = qcow2_co_copy_range_from,
6083 .bdrv_co_copy_range_to = qcow2_co_copy_range_to,
6084 .bdrv_co_truncate = qcow2_co_truncate,
6085 .bdrv_co_pwritev_compressed_part = qcow2_co_pwritev_compressed_part,
6086 .bdrv_make_empty = qcow2_make_empty,
6087
6088 .bdrv_snapshot_create = qcow2_snapshot_create,
6089 .bdrv_snapshot_goto = qcow2_snapshot_goto,
6090 .bdrv_snapshot_delete = qcow2_snapshot_delete,
6091 .bdrv_snapshot_list = qcow2_snapshot_list,
6092 .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
6093 .bdrv_measure = qcow2_measure,
6094 .bdrv_co_get_info = qcow2_co_get_info,
6095 .bdrv_get_specific_info = qcow2_get_specific_info,
6096
6097 .bdrv_co_save_vmstate = qcow2_co_save_vmstate,
6098 .bdrv_co_load_vmstate = qcow2_co_load_vmstate,
6099
6100 .is_format = true,
6101 .supports_backing = true,
6102 .bdrv_change_backing_file = qcow2_change_backing_file,
6103
6104 .bdrv_refresh_limits = qcow2_refresh_limits,
6105 .bdrv_co_invalidate_cache = qcow2_co_invalidate_cache,
6106 .bdrv_inactivate = qcow2_inactivate,
6107
6108 .create_opts = &qcow2_create_opts,
6109 .amend_opts = &qcow2_amend_opts,
6110 .strong_runtime_opts = qcow2_strong_runtime_opts,
6111 .mutable_opts = mutable_opts,
6112 .bdrv_co_check = qcow2_co_check,
6113 .bdrv_amend_options = qcow2_amend_options,
6114 .bdrv_co_amend = qcow2_co_amend,
6115
6116 .bdrv_detach_aio_context = qcow2_detach_aio_context,
6117 .bdrv_attach_aio_context = qcow2_attach_aio_context,
6118
6119 .bdrv_supports_persistent_dirty_bitmap =
6120 qcow2_supports_persistent_dirty_bitmap,
6121 .bdrv_co_can_store_new_dirty_bitmap = qcow2_co_can_store_new_dirty_bitmap,
6122 .bdrv_co_remove_persistent_dirty_bitmap =
6123 qcow2_co_remove_persistent_dirty_bitmap,
6124};
6125
6126static void bdrv_qcow2_init(void)
6127{
6128 bdrv_register(&bdrv_qcow2);
6129}
6130
6131block_init(bdrv_qcow2_init);
6132