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