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 l2_entry,
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 int64_t offset, int64_t bytes,
2314 QEMUIOVector *qiov,
2315 size_t qiov_offset,
2316 BdrvRequestFlags flags)
2317{
2318 BDRVQcow2State *s = bs->opaque;
2319 int ret = 0;
2320 unsigned int cur_bytes;
2321 uint64_t host_offset = 0;
2322 QCow2SubclusterType type;
2323 AioTaskPool *aio = NULL;
2324
2325 while (bytes != 0 && aio_task_pool_status(aio) == 0) {
2326
2327 cur_bytes = MIN(bytes, INT_MAX);
2328 if (s->crypto) {
2329 cur_bytes = MIN(cur_bytes,
2330 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2331 }
2332
2333 qemu_co_mutex_lock(&s->lock);
2334 ret = qcow2_get_host_offset(bs, offset, &cur_bytes,
2335 &host_offset, &type);
2336 qemu_co_mutex_unlock(&s->lock);
2337 if (ret < 0) {
2338 goto out;
2339 }
2340
2341 if (type == QCOW2_SUBCLUSTER_ZERO_PLAIN ||
2342 type == QCOW2_SUBCLUSTER_ZERO_ALLOC ||
2343 (type == QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && !bs->backing) ||
2344 (type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC && !bs->backing))
2345 {
2346 qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes);
2347 } else {
2348 if (!aio && cur_bytes != bytes) {
2349 aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
2350 }
2351 ret = qcow2_add_task(bs, aio, qcow2_co_preadv_task_entry, type,
2352 host_offset, offset, cur_bytes,
2353 qiov, qiov_offset, NULL);
2354 if (ret < 0) {
2355 goto out;
2356 }
2357 }
2358
2359 bytes -= cur_bytes;
2360 offset += cur_bytes;
2361 qiov_offset += cur_bytes;
2362 }
2363
2364out:
2365 if (aio) {
2366 aio_task_pool_wait_all(aio);
2367 if (ret == 0) {
2368 ret = aio_task_pool_status(aio);
2369 }
2370 g_free(aio);
2371 }
2372
2373 return ret;
2374}
2375
2376
2377
2378static bool merge_cow(uint64_t offset, unsigned bytes,
2379 QEMUIOVector *qiov, size_t qiov_offset,
2380 QCowL2Meta *l2meta)
2381{
2382 QCowL2Meta *m;
2383
2384 for (m = l2meta; m != NULL; m = m->next) {
2385
2386 if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) {
2387 continue;
2388 }
2389
2390
2391 if (m->skip_cow) {
2392 continue;
2393 }
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403 if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) {
2404
2405 assert(offset < l2meta_cow_start(m));
2406 assert(m->cow_start.nb_bytes == 0);
2407 continue;
2408 }
2409
2410
2411
2412 if (m->offset + m->cow_end.offset != offset + bytes) {
2413 assert(offset + bytes > m->offset + m->cow_end.offset);
2414 assert(m->cow_end.nb_bytes == 0);
2415 continue;
2416 }
2417
2418
2419
2420 if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) {
2421 continue;
2422 }
2423
2424 m->data_qiov = qiov;
2425 m->data_qiov_offset = qiov_offset;
2426 return true;
2427 }
2428
2429 return false;
2430}
2431
2432
2433
2434
2435
2436static int is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)
2437{
2438
2439
2440
2441
2442
2443
2444 int ret = bdrv_co_is_zero_fast(bs, m->offset + m->cow_start.offset,
2445 m->cow_start.nb_bytes);
2446 if (ret <= 0) {
2447 return ret;
2448 }
2449
2450 return bdrv_co_is_zero_fast(bs, m->offset + m->cow_end.offset,
2451 m->cow_end.nb_bytes);
2452}
2453
2454static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
2455{
2456 BDRVQcow2State *s = bs->opaque;
2457 QCowL2Meta *m;
2458
2459 if (!(s->data_file->bs->supported_zero_flags & BDRV_REQ_NO_FALLBACK)) {
2460 return 0;
2461 }
2462
2463 if (bs->encrypted) {
2464 return 0;
2465 }
2466
2467 for (m = l2meta; m != NULL; m = m->next) {
2468 int ret;
2469 uint64_t start_offset = m->alloc_offset + m->cow_start.offset;
2470 unsigned nb_bytes = m->cow_end.offset + m->cow_end.nb_bytes -
2471 m->cow_start.offset;
2472
2473 if (!m->cow_start.nb_bytes && !m->cow_end.nb_bytes) {
2474 continue;
2475 }
2476
2477 ret = is_zero_cow(bs, m);
2478 if (ret < 0) {
2479 return ret;
2480 } else if (ret == 0) {
2481 continue;
2482 }
2483
2484
2485
2486
2487
2488
2489 ret = qcow2_pre_write_overlap_check(bs, 0, start_offset, nb_bytes,
2490 true);
2491 if (ret < 0) {
2492 return ret;
2493 }
2494
2495 BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
2496 ret = bdrv_co_pwrite_zeroes(s->data_file, start_offset, nb_bytes,
2497 BDRV_REQ_NO_FALLBACK);
2498 if (ret < 0) {
2499 if (ret != -ENOTSUP && ret != -EAGAIN) {
2500 return ret;
2501 }
2502 continue;
2503 }
2504
2505 trace_qcow2_skip_cow(qemu_coroutine_self(), m->offset, m->nb_clusters);
2506 m->skip_cow = true;
2507 }
2508 return 0;
2509}
2510
2511
2512
2513
2514
2515
2516
2517static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs,
2518 uint64_t host_offset,
2519 uint64_t offset, uint64_t bytes,
2520 QEMUIOVector *qiov,
2521 uint64_t qiov_offset,
2522 QCowL2Meta *l2meta)
2523{
2524 int ret;
2525 BDRVQcow2State *s = bs->opaque;
2526 void *crypt_buf = NULL;
2527 QEMUIOVector encrypted_qiov;
2528
2529 if (bs->encrypted) {
2530 assert(s->crypto);
2531 assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
2532 crypt_buf = qemu_try_blockalign(bs->file->bs, bytes);
2533 if (crypt_buf == NULL) {
2534 ret = -ENOMEM;
2535 goto out_unlocked;
2536 }
2537 qemu_iovec_to_buf(qiov, qiov_offset, crypt_buf, bytes);
2538
2539 if (qcow2_co_encrypt(bs, host_offset, offset, crypt_buf, bytes) < 0) {
2540 ret = -EIO;
2541 goto out_unlocked;
2542 }
2543
2544 qemu_iovec_init_buf(&encrypted_qiov, crypt_buf, bytes);
2545 qiov = &encrypted_qiov;
2546 qiov_offset = 0;
2547 }
2548
2549
2550 ret = handle_alloc_space(bs, l2meta);
2551 if (ret < 0) {
2552 goto out_unlocked;
2553 }
2554
2555
2556
2557
2558
2559
2560
2561 if (!merge_cow(offset, bytes, qiov, qiov_offset, l2meta)) {
2562 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
2563 trace_qcow2_writev_data(qemu_coroutine_self(), host_offset);
2564 ret = bdrv_co_pwritev_part(s->data_file, host_offset,
2565 bytes, qiov, qiov_offset, 0);
2566 if (ret < 0) {
2567 goto out_unlocked;
2568 }
2569 }
2570
2571 qemu_co_mutex_lock(&s->lock);
2572
2573 ret = qcow2_handle_l2meta(bs, &l2meta, true);
2574 goto out_locked;
2575
2576out_unlocked:
2577 qemu_co_mutex_lock(&s->lock);
2578
2579out_locked:
2580 qcow2_handle_l2meta(bs, &l2meta, false);
2581 qemu_co_mutex_unlock(&s->lock);
2582
2583 qemu_vfree(crypt_buf);
2584
2585 return ret;
2586}
2587
2588static coroutine_fn int qcow2_co_pwritev_task_entry(AioTask *task)
2589{
2590 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
2591
2592 assert(!t->subcluster_type);
2593
2594 return qcow2_co_pwritev_task(t->bs, t->host_offset,
2595 t->offset, t->bytes, t->qiov, t->qiov_offset,
2596 t->l2meta);
2597}
2598
2599static coroutine_fn int qcow2_co_pwritev_part(
2600 BlockDriverState *bs, int64_t offset, int64_t bytes,
2601 QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags)
2602{
2603 BDRVQcow2State *s = bs->opaque;
2604 int offset_in_cluster;
2605 int ret;
2606 unsigned int cur_bytes;
2607 uint64_t host_offset;
2608 QCowL2Meta *l2meta = NULL;
2609 AioTaskPool *aio = NULL;
2610
2611 trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
2612
2613 while (bytes != 0 && aio_task_pool_status(aio) == 0) {
2614
2615 l2meta = NULL;
2616
2617 trace_qcow2_writev_start_part(qemu_coroutine_self());
2618 offset_in_cluster = offset_into_cluster(s, offset);
2619 cur_bytes = MIN(bytes, INT_MAX);
2620 if (bs->encrypted) {
2621 cur_bytes = MIN(cur_bytes,
2622 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size
2623 - offset_in_cluster);
2624 }
2625
2626 qemu_co_mutex_lock(&s->lock);
2627
2628 ret = qcow2_alloc_host_offset(bs, offset, &cur_bytes,
2629 &host_offset, &l2meta);
2630 if (ret < 0) {
2631 goto out_locked;
2632 }
2633
2634 ret = qcow2_pre_write_overlap_check(bs, 0, host_offset,
2635 cur_bytes, true);
2636 if (ret < 0) {
2637 goto out_locked;
2638 }
2639
2640 qemu_co_mutex_unlock(&s->lock);
2641
2642 if (!aio && cur_bytes != bytes) {
2643 aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
2644 }
2645 ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_task_entry, 0,
2646 host_offset, offset,
2647 cur_bytes, qiov, qiov_offset, l2meta);
2648 l2meta = NULL;
2649 if (ret < 0) {
2650 goto fail_nometa;
2651 }
2652
2653 bytes -= cur_bytes;
2654 offset += cur_bytes;
2655 qiov_offset += cur_bytes;
2656 trace_qcow2_writev_done_part(qemu_coroutine_self(), cur_bytes);
2657 }
2658 ret = 0;
2659
2660 qemu_co_mutex_lock(&s->lock);
2661
2662out_locked:
2663 qcow2_handle_l2meta(bs, &l2meta, false);
2664
2665 qemu_co_mutex_unlock(&s->lock);
2666
2667fail_nometa:
2668 if (aio) {
2669 aio_task_pool_wait_all(aio);
2670 if (ret == 0) {
2671 ret = aio_task_pool_status(aio);
2672 }
2673 g_free(aio);
2674 }
2675
2676 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
2677
2678 return ret;
2679}
2680
2681static int qcow2_inactivate(BlockDriverState *bs)
2682{
2683 BDRVQcow2State *s = bs->opaque;
2684 int ret, result = 0;
2685 Error *local_err = NULL;
2686
2687 qcow2_store_persistent_dirty_bitmaps(bs, true, &local_err);
2688 if (local_err != NULL) {
2689 result = -EINVAL;
2690 error_reportf_err(local_err, "Lost persistent bitmaps during "
2691 "inactivation of node '%s': ",
2692 bdrv_get_device_or_node_name(bs));
2693 }
2694
2695 ret = qcow2_cache_flush(bs, s->l2_table_cache);
2696 if (ret) {
2697 result = ret;
2698 error_report("Failed to flush the L2 table cache: %s",
2699 strerror(-ret));
2700 }
2701
2702 ret = qcow2_cache_flush(bs, s->refcount_block_cache);
2703 if (ret) {
2704 result = ret;
2705 error_report("Failed to flush the refcount block cache: %s",
2706 strerror(-ret));
2707 }
2708
2709 if (result == 0) {
2710 qcow2_mark_clean(bs);
2711 }
2712
2713 return result;
2714}
2715
2716static void qcow2_close(BlockDriverState *bs)
2717{
2718 BDRVQcow2State *s = bs->opaque;
2719 qemu_vfree(s->l1_table);
2720
2721 s->l1_table = NULL;
2722
2723 if (!(s->flags & BDRV_O_INACTIVE)) {
2724 qcow2_inactivate(bs);
2725 }
2726
2727 cache_clean_timer_del(bs);
2728 qcow2_cache_destroy(s->l2_table_cache);
2729 qcow2_cache_destroy(s->refcount_block_cache);
2730
2731 qcrypto_block_free(s->crypto);
2732 s->crypto = NULL;
2733 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
2734
2735 g_free(s->unknown_header_fields);
2736 cleanup_unknown_header_ext(bs);
2737
2738 g_free(s->image_data_file);
2739 g_free(s->image_backing_file);
2740 g_free(s->image_backing_format);
2741
2742 if (has_data_file(bs)) {
2743 bdrv_unref_child(bs, s->data_file);
2744 s->data_file = NULL;
2745 }
2746
2747 qcow2_refcount_close(bs);
2748 qcow2_free_snapshots(bs);
2749}
2750
2751static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
2752 Error **errp)
2753{
2754 ERRP_GUARD();
2755 BDRVQcow2State *s = bs->opaque;
2756 int flags = s->flags;
2757 QCryptoBlock *crypto = NULL;
2758 QDict *options;
2759 int ret;
2760
2761
2762
2763
2764
2765
2766 crypto = s->crypto;
2767 s->crypto = NULL;
2768
2769 qcow2_close(bs);
2770
2771 memset(s, 0, sizeof(BDRVQcow2State));
2772 options = qdict_clone_shallow(bs->options);
2773
2774 flags &= ~BDRV_O_INACTIVE;
2775 qemu_co_mutex_lock(&s->lock);
2776 ret = qcow2_do_open(bs, options, flags, errp);
2777 qemu_co_mutex_unlock(&s->lock);
2778 qobject_unref(options);
2779 if (ret < 0) {
2780 error_prepend(errp, "Could not reopen qcow2 layer: ");
2781 bs->drv = NULL;
2782 return;
2783 }
2784
2785 s->crypto = crypto;
2786}
2787
2788static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
2789 size_t len, size_t buflen)
2790{
2791 QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
2792 size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
2793
2794 if (buflen < ext_len) {
2795 return -ENOSPC;
2796 }
2797
2798 *ext_backing_fmt = (QCowExtension) {
2799 .magic = cpu_to_be32(magic),
2800 .len = cpu_to_be32(len),
2801 };
2802
2803 if (len) {
2804 memcpy(buf + sizeof(QCowExtension), s, len);
2805 }
2806
2807 return ext_len;
2808}
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818int qcow2_update_header(BlockDriverState *bs)
2819{
2820 BDRVQcow2State *s = bs->opaque;
2821 QCowHeader *header;
2822 char *buf;
2823 size_t buflen = s->cluster_size;
2824 int ret;
2825 uint64_t total_size;
2826 uint32_t refcount_table_clusters;
2827 size_t header_length;
2828 Qcow2UnknownHeaderExtension *uext;
2829
2830 buf = qemu_blockalign(bs, buflen);
2831
2832
2833 header = (QCowHeader*) buf;
2834
2835 if (buflen < sizeof(*header)) {
2836 ret = -ENOSPC;
2837 goto fail;
2838 }
2839
2840 header_length = sizeof(*header) + s->unknown_header_fields_size;
2841 total_size = bs->total_sectors * BDRV_SECTOR_SIZE;
2842 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3);
2843
2844 ret = validate_compression_type(s, NULL);
2845 if (ret) {
2846 goto fail;
2847 }
2848
2849 *header = (QCowHeader) {
2850
2851 .magic = cpu_to_be32(QCOW_MAGIC),
2852 .version = cpu_to_be32(s->qcow_version),
2853 .backing_file_offset = 0,
2854 .backing_file_size = 0,
2855 .cluster_bits = cpu_to_be32(s->cluster_bits),
2856 .size = cpu_to_be64(total_size),
2857 .crypt_method = cpu_to_be32(s->crypt_method_header),
2858 .l1_size = cpu_to_be32(s->l1_size),
2859 .l1_table_offset = cpu_to_be64(s->l1_table_offset),
2860 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset),
2861 .refcount_table_clusters = cpu_to_be32(refcount_table_clusters),
2862 .nb_snapshots = cpu_to_be32(s->nb_snapshots),
2863 .snapshots_offset = cpu_to_be64(s->snapshots_offset),
2864
2865
2866 .incompatible_features = cpu_to_be64(s->incompatible_features),
2867 .compatible_features = cpu_to_be64(s->compatible_features),
2868 .autoclear_features = cpu_to_be64(s->autoclear_features),
2869 .refcount_order = cpu_to_be32(s->refcount_order),
2870 .header_length = cpu_to_be32(header_length),
2871 .compression_type = s->compression_type,
2872 };
2873
2874
2875 switch (s->qcow_version) {
2876 case 2:
2877 ret = offsetof(QCowHeader, incompatible_features);
2878 break;
2879 case 3:
2880 ret = sizeof(*header);
2881 break;
2882 default:
2883 ret = -EINVAL;
2884 goto fail;
2885 }
2886
2887 buf += ret;
2888 buflen -= ret;
2889 memset(buf, 0, buflen);
2890
2891
2892 if (s->unknown_header_fields_size) {
2893 if (buflen < s->unknown_header_fields_size) {
2894 ret = -ENOSPC;
2895 goto fail;
2896 }
2897
2898 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size);
2899 buf += s->unknown_header_fields_size;
2900 buflen -= s->unknown_header_fields_size;
2901 }
2902
2903
2904 if (s->image_backing_format) {
2905 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BACKING_FORMAT,
2906 s->image_backing_format,
2907 strlen(s->image_backing_format),
2908 buflen);
2909 if (ret < 0) {
2910 goto fail;
2911 }
2912
2913 buf += ret;
2914 buflen -= ret;
2915 }
2916
2917
2918 if (has_data_file(bs) && s->image_data_file) {
2919 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_DATA_FILE,
2920 s->image_data_file, strlen(s->image_data_file),
2921 buflen);
2922 if (ret < 0) {
2923 goto fail;
2924 }
2925
2926 buf += ret;
2927 buflen -= ret;
2928 }
2929
2930
2931 if (s->crypto_header.offset != 0) {
2932 s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset);
2933 s->crypto_header.length = cpu_to_be64(s->crypto_header.length);
2934 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_CRYPTO_HEADER,
2935 &s->crypto_header, sizeof(s->crypto_header),
2936 buflen);
2937 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset);
2938 s->crypto_header.length = be64_to_cpu(s->crypto_header.length);
2939 if (ret < 0) {
2940 goto fail;
2941 }
2942 buf += ret;
2943 buflen -= ret;
2944 }
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954 if (s->qcow_version >= 3 && s->cluster_size > 4096) {
2955 static const Qcow2Feature features[] = {
2956 {
2957 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2958 .bit = QCOW2_INCOMPAT_DIRTY_BITNR,
2959 .name = "dirty bit",
2960 },
2961 {
2962 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2963 .bit = QCOW2_INCOMPAT_CORRUPT_BITNR,
2964 .name = "corrupt bit",
2965 },
2966 {
2967 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2968 .bit = QCOW2_INCOMPAT_DATA_FILE_BITNR,
2969 .name = "external data file",
2970 },
2971 {
2972 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2973 .bit = QCOW2_INCOMPAT_COMPRESSION_BITNR,
2974 .name = "compression type",
2975 },
2976 {
2977 .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
2978 .bit = QCOW2_INCOMPAT_EXTL2_BITNR,
2979 .name = "extended L2 entries",
2980 },
2981 {
2982 .type = QCOW2_FEAT_TYPE_COMPATIBLE,
2983 .bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
2984 .name = "lazy refcounts",
2985 },
2986 {
2987 .type = QCOW2_FEAT_TYPE_AUTOCLEAR,
2988 .bit = QCOW2_AUTOCLEAR_BITMAPS_BITNR,
2989 .name = "bitmaps",
2990 },
2991 {
2992 .type = QCOW2_FEAT_TYPE_AUTOCLEAR,
2993 .bit = QCOW2_AUTOCLEAR_DATA_FILE_RAW_BITNR,
2994 .name = "raw external data",
2995 },
2996 };
2997
2998 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_FEATURE_TABLE,
2999 features, sizeof(features), buflen);
3000 if (ret < 0) {
3001 goto fail;
3002 }
3003 buf += ret;
3004 buflen -= ret;
3005 }
3006
3007
3008 if (s->nb_bitmaps > 0) {
3009 Qcow2BitmapHeaderExt bitmaps_header = {
3010 .nb_bitmaps = cpu_to_be32(s->nb_bitmaps),
3011 .bitmap_directory_size =
3012 cpu_to_be64(s->bitmap_directory_size),
3013 .bitmap_directory_offset =
3014 cpu_to_be64(s->bitmap_directory_offset)
3015 };
3016 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_BITMAPS,
3017 &bitmaps_header, sizeof(bitmaps_header),
3018 buflen);
3019 if (ret < 0) {
3020 goto fail;
3021 }
3022 buf += ret;
3023 buflen -= ret;
3024 }
3025
3026
3027 QLIST_FOREACH(uext, &s->unknown_header_ext, next) {
3028 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen);
3029 if (ret < 0) {
3030 goto fail;
3031 }
3032
3033 buf += ret;
3034 buflen -= ret;
3035 }
3036
3037
3038 ret = header_ext_add(buf, QCOW2_EXT_MAGIC_END, NULL, 0, buflen);
3039 if (ret < 0) {
3040 goto fail;
3041 }
3042
3043 buf += ret;
3044 buflen -= ret;
3045
3046
3047 if (s->image_backing_file) {
3048 size_t backing_file_len = strlen(s->image_backing_file);
3049
3050 if (buflen < backing_file_len) {
3051 ret = -ENOSPC;
3052 goto fail;
3053 }
3054
3055
3056 strncpy(buf, s->image_backing_file, buflen);
3057
3058 header->backing_file_offset = cpu_to_be64(buf - ((char*) header));
3059 header->backing_file_size = cpu_to_be32(backing_file_len);
3060 }
3061
3062
3063 ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
3064 if (ret < 0) {
3065 goto fail;
3066 }
3067
3068 ret = 0;
3069fail:
3070 qemu_vfree(header);
3071 return ret;
3072}
3073
3074static int qcow2_change_backing_file(BlockDriverState *bs,
3075 const char *backing_file, const char *backing_fmt)
3076{
3077 BDRVQcow2State *s = bs->opaque;
3078
3079
3080
3081 if (backing_file && data_file_is_raw(bs)) {
3082 return -EINVAL;
3083 }
3084
3085 if (backing_file && strlen(backing_file) > 1023) {
3086 return -EINVAL;
3087 }
3088
3089 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file),
3090 backing_file ?: "");
3091 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: "");
3092 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: "");
3093
3094 g_free(s->image_backing_file);
3095 g_free(s->image_backing_format);
3096
3097 s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL;
3098 s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL;
3099
3100 return qcow2_update_header(bs);
3101}
3102
3103static int qcow2_set_up_encryption(BlockDriverState *bs,
3104 QCryptoBlockCreateOptions *cryptoopts,
3105 Error **errp)
3106{
3107 BDRVQcow2State *s = bs->opaque;
3108 QCryptoBlock *crypto = NULL;
3109 int fmt, ret;
3110
3111 switch (cryptoopts->format) {
3112 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
3113 fmt = QCOW_CRYPT_LUKS;
3114 break;
3115 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
3116 fmt = QCOW_CRYPT_AES;
3117 break;
3118 default:
3119 error_setg(errp, "Crypto format not supported in qcow2");
3120 return -EINVAL;
3121 }
3122
3123 s->crypt_method_header = fmt;
3124
3125 crypto = qcrypto_block_create(cryptoopts, "encrypt.",
3126 qcow2_crypto_hdr_init_func,
3127 qcow2_crypto_hdr_write_func,
3128 bs, errp);
3129 if (!crypto) {
3130 return -EINVAL;
3131 }
3132
3133 ret = qcow2_update_header(bs);
3134 if (ret < 0) {
3135 error_setg_errno(errp, -ret, "Could not write encryption header");
3136 goto out;
3137 }
3138
3139 ret = 0;
3140 out:
3141 qcrypto_block_free(crypto);
3142 return ret;
3143}
3144
3145
3146
3147
3148
3149
3150
3151
3152static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
3153 uint64_t new_length, PreallocMode mode,
3154 Error **errp)
3155{
3156 BDRVQcow2State *s = bs->opaque;
3157 uint64_t bytes;
3158 uint64_t host_offset = 0;
3159 int64_t file_length;
3160 unsigned int cur_bytes;
3161 int ret;
3162 QCowL2Meta *meta = NULL, *m;
3163
3164 assert(offset <= new_length);
3165 bytes = new_length - offset;
3166
3167 while (bytes) {
3168 cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size));
3169 ret = qcow2_alloc_host_offset(bs, offset, &cur_bytes,
3170 &host_offset, &meta);
3171 if (ret < 0) {
3172 error_setg_errno(errp, -ret, "Allocating clusters failed");
3173 goto out;
3174 }
3175
3176 for (m = meta; m != NULL; m = m->next) {
3177 m->prealloc = true;
3178 }
3179
3180 ret = qcow2_handle_l2meta(bs, &meta, true);
3181 if (ret < 0) {
3182 error_setg_errno(errp, -ret, "Mapping clusters failed");
3183 goto out;
3184 }
3185
3186
3187
3188 bytes -= cur_bytes;
3189 offset += cur_bytes;
3190 }
3191
3192
3193
3194
3195
3196
3197 file_length = bdrv_getlength(s->data_file->bs);
3198 if (file_length < 0) {
3199 error_setg_errno(errp, -file_length, "Could not get file size");
3200 ret = file_length;
3201 goto out;
3202 }
3203
3204 if (host_offset + cur_bytes > file_length) {
3205 if (mode == PREALLOC_MODE_METADATA) {
3206 mode = PREALLOC_MODE_OFF;
3207 }
3208 ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
3209 mode, 0, errp);
3210 if (ret < 0) {
3211 goto out;
3212 }
3213 }
3214
3215 ret = 0;
3216
3217out:
3218 qcow2_handle_l2meta(bs, &meta, false);
3219 return ret;
3220}
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
3232 int refcount_order, bool generous_increase,
3233 uint64_t *refblock_count)
3234{
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244 int64_t blocks_per_table_cluster = cluster_size / REFTABLE_ENTRY_SIZE;
3245 int64_t refcounts_per_block = cluster_size * 8 / (1 << refcount_order);
3246 int64_t table = 0;
3247 int64_t blocks = 0;
3248 int64_t last;
3249 int64_t n = 0;
3250
3251 do {
3252 last = n;
3253 blocks = DIV_ROUND_UP(clusters + table + blocks, refcounts_per_block);
3254 table = DIV_ROUND_UP(blocks, blocks_per_table_cluster);
3255 n = clusters + blocks + table;
3256
3257 if (n == last && generous_increase) {
3258 clusters += DIV_ROUND_UP(table, 2);
3259 n = 0;
3260 generous_increase = false;
3261 }
3262 } while (n != last);
3263
3264 if (refblock_count) {
3265 *refblock_count = blocks;
3266 }
3267
3268 return (blocks + table) * cluster_size;
3269}
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281static int64_t qcow2_calc_prealloc_size(int64_t total_size,
3282 size_t cluster_size,
3283 int refcount_order,
3284 bool extended_l2)
3285{
3286 int64_t meta_size = 0;
3287 uint64_t nl1e, nl2e;
3288 int64_t aligned_total_size = ROUND_UP(total_size, cluster_size);
3289 size_t l2e_size = extended_l2 ? L2E_SIZE_EXTENDED : L2E_SIZE_NORMAL;
3290
3291
3292 meta_size += cluster_size;
3293
3294
3295 nl2e = aligned_total_size / cluster_size;
3296 nl2e = ROUND_UP(nl2e, cluster_size / l2e_size);
3297 meta_size += nl2e * l2e_size;
3298
3299
3300 nl1e = nl2e * l2e_size / cluster_size;
3301 nl1e = ROUND_UP(nl1e, cluster_size / L1E_SIZE);
3302 meta_size += nl1e * L1E_SIZE;
3303
3304
3305 meta_size += qcow2_refcount_metadata_size(
3306 (meta_size + aligned_total_size) / cluster_size,
3307 cluster_size, refcount_order, false, NULL);
3308
3309 return meta_size + aligned_total_size;
3310}
3311
3312static bool validate_cluster_size(size_t cluster_size, bool extended_l2,
3313 Error **errp)
3314{
3315 int cluster_bits = ctz32(cluster_size);
3316 if (cluster_bits < MIN_CLUSTER_BITS || cluster_bits > MAX_CLUSTER_BITS ||
3317 (1 << cluster_bits) != cluster_size)
3318 {
3319 error_setg(errp, "Cluster size must be a power of two between %d and "
3320 "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10));
3321 return false;
3322 }
3323
3324 if (extended_l2) {
3325 unsigned min_cluster_size =
3326 (1 << MIN_CLUSTER_BITS) * QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER;
3327 if (cluster_size < min_cluster_size) {
3328 error_setg(errp, "Extended L2 entries are only supported with "
3329 "cluster sizes of at least %u bytes", min_cluster_size);
3330 return false;
3331 }
3332 }
3333
3334 return true;
3335}
3336
3337static size_t qcow2_opt_get_cluster_size_del(QemuOpts *opts, bool extended_l2,
3338 Error **errp)
3339{
3340 size_t cluster_size;
3341
3342 cluster_size = qemu_opt_get_size_del(opts, BLOCK_OPT_CLUSTER_SIZE,
3343 DEFAULT_CLUSTER_SIZE);
3344 if (!validate_cluster_size(cluster_size, extended_l2, errp)) {
3345 return 0;
3346 }
3347 return cluster_size;
3348}
3349
3350static int qcow2_opt_get_version_del(QemuOpts *opts, Error **errp)
3351{
3352 char *buf;
3353 int ret;
3354
3355 buf = qemu_opt_get_del(opts, BLOCK_OPT_COMPAT_LEVEL);
3356 if (!buf) {
3357 ret = 3;
3358 } else if (!strcmp(buf, "0.10")) {
3359 ret = 2;
3360 } else if (!strcmp(buf, "1.1")) {
3361 ret = 3;
3362 } else {
3363 error_setg(errp, "Invalid compatibility level: '%s'", buf);
3364 ret = -EINVAL;
3365 }
3366 g_free(buf);
3367 return ret;
3368}
3369
3370static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
3371 Error **errp)
3372{
3373 uint64_t refcount_bits;
3374
3375 refcount_bits = qemu_opt_get_number_del(opts, BLOCK_OPT_REFCOUNT_BITS, 16);
3376 if (refcount_bits > 64 || !is_power_of_2(refcount_bits)) {
3377 error_setg(errp, "Refcount width must be a power of two and may not "
3378 "exceed 64 bits");
3379 return 0;
3380 }
3381
3382 if (version < 3 && refcount_bits != 16) {
3383 error_setg(errp, "Different refcount widths than 16 bits require "
3384 "compatibility level 1.1 or above (use compat=1.1 or "
3385 "greater)");
3386 return 0;
3387 }
3388
3389 return refcount_bits;
3390}
3391
3392static int coroutine_fn
3393qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
3394{
3395 BlockdevCreateOptionsQcow2 *qcow2_opts;
3396 QDict *options;
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410 BlockBackend *blk = NULL;
3411 BlockDriverState *bs = NULL;
3412 BlockDriverState *data_bs = NULL;
3413 QCowHeader *header;
3414 size_t cluster_size;
3415 int version;
3416 int refcount_order;
3417 uint64_t *refcount_table;
3418 int ret;
3419 uint8_t compression_type = QCOW2_COMPRESSION_TYPE_ZLIB;
3420
3421 assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2);
3422 qcow2_opts = &create_options->u.qcow2;
3423
3424 bs = bdrv_open_blockdev_ref(qcow2_opts->file, errp);
3425 if (bs == NULL) {
3426 return -EIO;
3427 }
3428
3429
3430 if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) {
3431 error_setg(errp, "Image size must be a multiple of %u bytes",
3432 (unsigned) BDRV_SECTOR_SIZE);
3433 ret = -EINVAL;
3434 goto out;
3435 }
3436
3437 if (qcow2_opts->has_version) {
3438 switch (qcow2_opts->version) {
3439 case BLOCKDEV_QCOW2_VERSION_V2:
3440 version = 2;
3441 break;
3442 case BLOCKDEV_QCOW2_VERSION_V3:
3443 version = 3;
3444 break;
3445 default:
3446 g_assert_not_reached();
3447 }
3448 } else {
3449 version = 3;
3450 }
3451
3452 if (qcow2_opts->has_cluster_size) {
3453 cluster_size = qcow2_opts->cluster_size;
3454 } else {
3455 cluster_size = DEFAULT_CLUSTER_SIZE;
3456 }
3457
3458 if (!qcow2_opts->has_extended_l2) {
3459 qcow2_opts->extended_l2 = false;
3460 }
3461 if (qcow2_opts->extended_l2) {
3462 if (version < 3) {
3463 error_setg(errp, "Extended L2 entries are only supported with "
3464 "compatibility level 1.1 and above (use version=v3 or "
3465 "greater)");
3466 ret = -EINVAL;
3467 goto out;
3468 }
3469 }
3470
3471 if (!validate_cluster_size(cluster_size, qcow2_opts->extended_l2, errp)) {
3472 ret = -EINVAL;
3473 goto out;
3474 }
3475
3476 if (!qcow2_opts->has_preallocation) {
3477 qcow2_opts->preallocation = PREALLOC_MODE_OFF;
3478 }
3479 if (qcow2_opts->has_backing_file &&
3480 qcow2_opts->preallocation != PREALLOC_MODE_OFF &&
3481 !qcow2_opts->extended_l2)
3482 {
3483 error_setg(errp, "Backing file and preallocation can only be used at "
3484 "the same time if extended_l2 is on");
3485 ret = -EINVAL;
3486 goto out;
3487 }
3488 if (qcow2_opts->has_backing_fmt && !qcow2_opts->has_backing_file) {
3489 error_setg(errp, "Backing format cannot be used without backing file");
3490 ret = -EINVAL;
3491 goto out;
3492 }
3493
3494 if (!qcow2_opts->has_lazy_refcounts) {
3495 qcow2_opts->lazy_refcounts = false;
3496 }
3497 if (version < 3 && qcow2_opts->lazy_refcounts) {
3498 error_setg(errp, "Lazy refcounts only supported with compatibility "
3499 "level 1.1 and above (use version=v3 or greater)");
3500 ret = -EINVAL;
3501 goto out;
3502 }
3503
3504 if (!qcow2_opts->has_refcount_bits) {
3505 qcow2_opts->refcount_bits = 16;
3506 }
3507 if (qcow2_opts->refcount_bits > 64 ||
3508 !is_power_of_2(qcow2_opts->refcount_bits))
3509 {
3510 error_setg(errp, "Refcount width must be a power of two and may not "
3511 "exceed 64 bits");
3512 ret = -EINVAL;
3513 goto out;
3514 }
3515 if (version < 3 && qcow2_opts->refcount_bits != 16) {
3516 error_setg(errp, "Different refcount widths than 16 bits require "
3517 "compatibility level 1.1 or above (use version=v3 or "
3518 "greater)");
3519 ret = -EINVAL;
3520 goto out;
3521 }
3522 refcount_order = ctz32(qcow2_opts->refcount_bits);
3523
3524 if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) {
3525 error_setg(errp, "data-file-raw requires data-file");
3526 ret = -EINVAL;
3527 goto out;
3528 }
3529 if (qcow2_opts->data_file_raw && qcow2_opts->has_backing_file) {
3530 error_setg(errp, "Backing file and data-file-raw cannot be used at "
3531 "the same time");
3532 ret = -EINVAL;
3533 goto out;
3534 }
3535 if (qcow2_opts->data_file_raw &&
3536 qcow2_opts->preallocation == PREALLOC_MODE_OFF)
3537 {
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548 qcow2_opts->preallocation = PREALLOC_MODE_METADATA;
3549
3550
3551
3552
3553
3554
3555 assert(!qcow2_opts->has_backing_file);
3556 }
3557
3558 if (qcow2_opts->data_file) {
3559 if (version < 3) {
3560 error_setg(errp, "External data files are only supported with "
3561 "compatibility level 1.1 and above (use version=v3 or "
3562 "greater)");
3563 ret = -EINVAL;
3564 goto out;
3565 }
3566 data_bs = bdrv_open_blockdev_ref(qcow2_opts->data_file, errp);
3567 if (data_bs == NULL) {
3568 ret = -EIO;
3569 goto out;
3570 }
3571 }
3572
3573 if (qcow2_opts->has_compression_type &&
3574 qcow2_opts->compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) {
3575
3576 ret = -EINVAL;
3577
3578 if (version < 3) {
3579 error_setg(errp, "Non-zlib compression type is only supported with "
3580 "compatibility level 1.1 and above (use version=v3 or "
3581 "greater)");
3582 goto out;
3583 }
3584
3585 switch (qcow2_opts->compression_type) {
3586#ifdef CONFIG_ZSTD
3587 case QCOW2_COMPRESSION_TYPE_ZSTD:
3588 break;
3589#endif
3590 default:
3591 error_setg(errp, "Unknown compression type");
3592 goto out;
3593 }
3594
3595 compression_type = qcow2_opts->compression_type;
3596 }
3597
3598
3599 blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
3600 errp);
3601 if (!blk) {
3602 ret = -EPERM;
3603 goto out;
3604 }
3605 blk_set_allow_write_beyond_eof(blk, true);
3606
3607
3608 QEMU_BUILD_BUG_ON((1 << MIN_CLUSTER_BITS) < sizeof(*header));
3609 header = g_malloc0(cluster_size);
3610 *header = (QCowHeader) {
3611 .magic = cpu_to_be32(QCOW_MAGIC),
3612 .version = cpu_to_be32(version),
3613 .cluster_bits = cpu_to_be32(ctz32(cluster_size)),
3614 .size = cpu_to_be64(0),
3615 .l1_table_offset = cpu_to_be64(0),
3616 .l1_size = cpu_to_be32(0),
3617 .refcount_table_offset = cpu_to_be64(cluster_size),
3618 .refcount_table_clusters = cpu_to_be32(1),
3619 .refcount_order = cpu_to_be32(refcount_order),
3620
3621 .compression_type = compression_type,
3622 .header_length = cpu_to_be32(sizeof(*header)),
3623 };
3624
3625
3626 header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);
3627
3628 if (qcow2_opts->lazy_refcounts) {
3629 header->compatible_features |=
3630 cpu_to_be64(QCOW2_COMPAT_LAZY_REFCOUNTS);
3631 }
3632 if (data_bs) {
3633 header->incompatible_features |=
3634 cpu_to_be64(QCOW2_INCOMPAT_DATA_FILE);
3635 }
3636 if (qcow2_opts->data_file_raw) {
3637 header->autoclear_features |=
3638 cpu_to_be64(QCOW2_AUTOCLEAR_DATA_FILE_RAW);
3639 }
3640 if (compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) {
3641 header->incompatible_features |=
3642 cpu_to_be64(QCOW2_INCOMPAT_COMPRESSION);
3643 }
3644
3645 if (qcow2_opts->extended_l2) {
3646 header->incompatible_features |=
3647 cpu_to_be64(QCOW2_INCOMPAT_EXTL2);
3648 }
3649
3650 ret = blk_pwrite(blk, 0, header, cluster_size, 0);
3651 g_free(header);
3652 if (ret < 0) {
3653 error_setg_errno(errp, -ret, "Could not write qcow2 header");
3654 goto out;
3655 }
3656
3657
3658 refcount_table = g_malloc0(2 * cluster_size);
3659 refcount_table[0] = cpu_to_be64(2 * cluster_size);
3660 ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
3661 g_free(refcount_table);
3662
3663 if (ret < 0) {
3664 error_setg_errno(errp, -ret, "Could not write refcount table");
3665 goto out;
3666 }
3667
3668 blk_unref(blk);
3669 blk = NULL;
3670
3671
3672
3673
3674
3675
3676 options = qdict_new();
3677 qdict_put_str(options, "driver", "qcow2");
3678 qdict_put_str(options, "file", bs->node_name);
3679 if (data_bs) {
3680 qdict_put_str(options, "data-file", data_bs->node_name);
3681 }
3682 blk = blk_new_open(NULL, NULL, options,
3683 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
3684 errp);
3685 if (blk == NULL) {
3686 ret = -EIO;
3687 goto out;
3688 }
3689
3690 ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
3691 if (ret < 0) {
3692 error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
3693 "header and refcount table");
3694 goto out;
3695
3696 } else if (ret != 0) {
3697 error_report("Huh, first cluster in empty image is already in use?");
3698 abort();
3699 }
3700
3701
3702 if (data_bs) {
3703 BDRVQcow2State *s = blk_bs(blk)->opaque;
3704 s->image_data_file = g_strdup(data_bs->filename);
3705 }
3706
3707
3708 ret = qcow2_update_header(blk_bs(blk));
3709 if (ret < 0) {
3710 error_setg_errno(errp, -ret, "Could not update qcow2 header");
3711 goto out;
3712 }
3713
3714
3715 ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
3716 0, errp);
3717 if (ret < 0) {
3718 error_prepend(errp, "Could not resize image: ");
3719 goto out;
3720 }
3721
3722
3723 if (qcow2_opts->has_backing_file) {
3724 const char *backing_format = NULL;
3725
3726 if (qcow2_opts->has_backing_fmt) {
3727 backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt);
3728 }
3729
3730 ret = bdrv_change_backing_file(blk_bs(blk), qcow2_opts->backing_file,
3731 backing_format, false);
3732 if (ret < 0) {
3733 error_setg_errno(errp, -ret, "Could not assign backing file '%s' "
3734 "with format '%s'", qcow2_opts->backing_file,
3735 backing_format);
3736 goto out;
3737 }
3738 }
3739
3740
3741 if (qcow2_opts->has_encrypt) {
3742 ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
3743 if (ret < 0) {
3744 goto out;
3745 }
3746 }
3747
3748 blk_unref(blk);
3749 blk = NULL;
3750
3751
3752
3753
3754
3755
3756
3757 options = qdict_new();
3758 qdict_put_str(options, "driver", "qcow2");
3759 qdict_put_str(options, "file", bs->node_name);
3760 if (data_bs) {
3761 qdict_put_str(options, "data-file", data_bs->node_name);
3762 }
3763 blk = blk_new_open(NULL, NULL, options,
3764 BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
3765 errp);
3766 if (blk == NULL) {
3767 ret = -EIO;
3768 goto out;
3769 }
3770
3771 ret = 0;
3772out:
3773 blk_unref(blk);
3774 bdrv_unref(bs);
3775 bdrv_unref(data_bs);
3776 return ret;
3777}
3778
3779static int coroutine_fn qcow2_co_create_opts(BlockDriver *drv,
3780 const char *filename,
3781 QemuOpts *opts,
3782 Error **errp)
3783{
3784 BlockdevCreateOptions *create_options = NULL;
3785 QDict *qdict;
3786 Visitor *v;
3787 BlockDriverState *bs = NULL;
3788 BlockDriverState *data_bs = NULL;
3789 const char *val;
3790 int ret;
3791
3792
3793
3794
3795
3796 qdict = qemu_opts_to_qdict_filtered(opts, NULL, bdrv_qcow2.create_opts,
3797 true);
3798
3799
3800 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT);
3801 if (val && !strcmp(val, "on")) {
3802 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT, "qcow");
3803 } else if (val && !strcmp(val, "off")) {
3804 qdict_del(qdict, BLOCK_OPT_ENCRYPT);
3805 }
3806
3807 val = qdict_get_try_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT);
3808 if (val && !strcmp(val, "aes")) {
3809 qdict_put_str(qdict, BLOCK_OPT_ENCRYPT_FORMAT, "qcow");
3810 }
3811
3812
3813
3814 val = qdict_get_try_str(qdict, BLOCK_OPT_COMPAT_LEVEL);
3815 if (val && !strcmp(val, "0.10")) {
3816 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v2");
3817 } else if (val && !strcmp(val, "1.1")) {
3818 qdict_put_str(qdict, BLOCK_OPT_COMPAT_LEVEL, "v3");
3819 }
3820
3821
3822 static const QDictRenames opt_renames[] = {
3823 { BLOCK_OPT_BACKING_FILE, "backing-file" },
3824 { BLOCK_OPT_BACKING_FMT, "backing-fmt" },
3825 { BLOCK_OPT_CLUSTER_SIZE, "cluster-size" },
3826 { BLOCK_OPT_LAZY_REFCOUNTS, "lazy-refcounts" },
3827 { BLOCK_OPT_EXTL2, "extended-l2" },
3828 { BLOCK_OPT_REFCOUNT_BITS, "refcount-bits" },
3829 { BLOCK_OPT_ENCRYPT, BLOCK_OPT_ENCRYPT_FORMAT },
3830 { BLOCK_OPT_COMPAT_LEVEL, "version" },
3831 { BLOCK_OPT_DATA_FILE_RAW, "data-file-raw" },
3832 { BLOCK_OPT_COMPRESSION_TYPE, "compression-type" },
3833 { NULL, NULL },
3834 };
3835
3836 if (!qdict_rename_keys(qdict, opt_renames, errp)) {
3837 ret = -EINVAL;
3838 goto finish;
3839 }
3840
3841
3842 ret = bdrv_create_file(filename, opts, errp);
3843 if (ret < 0) {
3844 goto finish;
3845 }
3846
3847 bs = bdrv_open(filename, NULL, NULL,
3848 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
3849 if (bs == NULL) {
3850 ret = -EIO;
3851 goto finish;
3852 }
3853
3854
3855 val = qdict_get_try_str(qdict, BLOCK_OPT_DATA_FILE);
3856 if (val) {
3857 ret = bdrv_create_file(val, opts, errp);
3858 if (ret < 0) {
3859 goto finish;
3860 }
3861
3862 data_bs = bdrv_open(val, NULL, NULL,
3863 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
3864 errp);
3865 if (data_bs == NULL) {
3866 ret = -EIO;
3867 goto finish;
3868 }
3869
3870 qdict_del(qdict, BLOCK_OPT_DATA_FILE);
3871 qdict_put_str(qdict, "data-file", data_bs->node_name);
3872 }
3873
3874
3875 qdict_put_str(qdict, "driver", "qcow2");
3876 qdict_put_str(qdict, "file", bs->node_name);
3877
3878
3879 v = qobject_input_visitor_new_flat_confused(qdict, errp);
3880 if (!v) {
3881 ret = -EINVAL;
3882 goto finish;
3883 }
3884
3885 visit_type_BlockdevCreateOptions(v, NULL, &create_options, errp);
3886 visit_free(v);
3887 if (!create_options) {
3888 ret = -EINVAL;
3889 goto finish;
3890 }
3891
3892
3893 create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size,
3894 BDRV_SECTOR_SIZE);
3895
3896
3897 ret = qcow2_co_create(create_options, errp);
3898finish:
3899 if (ret < 0) {
3900 bdrv_co_delete_file_noerr(bs);
3901 bdrv_co_delete_file_noerr(data_bs);
3902 } else {
3903 ret = 0;
3904 }
3905
3906 qobject_unref(qdict);
3907 bdrv_unref(bs);
3908 bdrv_unref(data_bs);
3909 qapi_free_BlockdevCreateOptions(create_options);
3910 return ret;
3911}
3912
3913
3914static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
3915{
3916 int64_t nr;
3917 int res;
3918
3919
3920 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3921 bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset;
3922 }
3923
3924 if (!bytes) {
3925 return true;
3926 }
3927
3928
3929
3930
3931
3932
3933
3934 do {
3935 res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
3936 offset += nr;
3937 bytes -= nr;
3938 } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);
3939
3940 return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
3941}
3942
3943static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
3944 int64_t offset, int64_t bytes, BdrvRequestFlags flags)
3945{
3946 int ret;
3947 BDRVQcow2State *s = bs->opaque;
3948
3949 uint32_t head = offset_into_subcluster(s, offset);
3950 uint32_t tail = ROUND_UP(offset + bytes, s->subcluster_size) -
3951 (offset + bytes);
3952
3953 trace_qcow2_pwrite_zeroes_start_req(qemu_coroutine_self(), offset, bytes);
3954 if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) {
3955 tail = 0;
3956 }
3957
3958 if (head || tail) {
3959 uint64_t off;
3960 unsigned int nr;
3961 QCow2SubclusterType type;
3962
3963 assert(head + bytes + tail <= s->subcluster_size);
3964
3965
3966 if (!(is_zero(bs, offset - head, head) &&
3967 is_zero(bs, offset + bytes, tail))) {
3968 return -ENOTSUP;
3969 }
3970
3971 qemu_co_mutex_lock(&s->lock);
3972
3973 offset -= head;
3974 bytes = s->subcluster_size;
3975 nr = s->subcluster_size;
3976 ret = qcow2_get_host_offset(bs, offset, &nr, &off, &type);
3977 if (ret < 0 ||
3978 (type != QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN &&
3979 type != QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC &&
3980 type != QCOW2_SUBCLUSTER_ZERO_PLAIN &&
3981 type != QCOW2_SUBCLUSTER_ZERO_ALLOC)) {
3982 qemu_co_mutex_unlock(&s->lock);
3983 return ret < 0 ? ret : -ENOTSUP;
3984 }
3985 } else {
3986 qemu_co_mutex_lock(&s->lock);
3987 }
3988
3989 trace_qcow2_pwrite_zeroes(qemu_coroutine_self(), offset, bytes);
3990
3991
3992 ret = qcow2_subcluster_zeroize(bs, offset, bytes, flags);
3993 qemu_co_mutex_unlock(&s->lock);
3994
3995 return ret;
3996}
3997
3998static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
3999 int64_t offset, int64_t bytes)
4000{
4001 int ret;
4002 BDRVQcow2State *s = bs->opaque;
4003
4004
4005
4006 if (s->qcow_version < 3 && bs->backing) {
4007 return -ENOTSUP;
4008 }
4009
4010 if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) {
4011 assert(bytes < s->cluster_size);
4012
4013
4014 if (!QEMU_IS_ALIGNED(offset, s->cluster_size) ||
4015 offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) {
4016 return -ENOTSUP;
4017 }
4018 }
4019
4020 qemu_co_mutex_lock(&s->lock);
4021 ret = qcow2_cluster_discard(bs, offset, bytes, QCOW2_DISCARD_REQUEST,
4022 false);
4023 qemu_co_mutex_unlock(&s->lock);
4024 return ret;
4025}
4026
4027static int coroutine_fn
4028qcow2_co_copy_range_from(BlockDriverState *bs,
4029 BdrvChild *src, int64_t src_offset,
4030 BdrvChild *dst, int64_t dst_offset,
4031 int64_t bytes, BdrvRequestFlags read_flags,
4032 BdrvRequestFlags write_flags)
4033{
4034 BDRVQcow2State *s = bs->opaque;
4035 int ret;
4036 unsigned int cur_bytes;
4037 BdrvChild *child = NULL;
4038 BdrvRequestFlags cur_write_flags;
4039
4040 assert(!bs->encrypted);
4041 qemu_co_mutex_lock(&s->lock);
4042
4043 while (bytes != 0) {
4044 uint64_t copy_offset = 0;
4045 QCow2SubclusterType type;
4046
4047 cur_bytes = MIN(bytes, INT_MAX);
4048 cur_write_flags = write_flags;
4049
4050 ret = qcow2_get_host_offset(bs, src_offset, &cur_bytes,
4051 ©_offset, &type);
4052 if (ret < 0) {
4053 goto out;
4054 }
4055
4056 switch (type) {
4057 case QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN:
4058 case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
4059 if (bs->backing && bs->backing->bs) {
4060 int64_t backing_length = bdrv_getlength(bs->backing->bs);
4061 if (src_offset >= backing_length) {
4062 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4063 } else {
4064 child = bs->backing;
4065 cur_bytes = MIN(cur_bytes, backing_length - src_offset);
4066 copy_offset = src_offset;
4067 }
4068 } else {
4069 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4070 }
4071 break;
4072
4073 case QCOW2_SUBCLUSTER_ZERO_PLAIN:
4074 case QCOW2_SUBCLUSTER_ZERO_ALLOC:
4075 cur_write_flags |= BDRV_REQ_ZERO_WRITE;
4076 break;
4077
4078 case QCOW2_SUBCLUSTER_COMPRESSED:
4079 ret = -ENOTSUP;
4080 goto out;
4081
4082 case QCOW2_SUBCLUSTER_NORMAL:
4083 child = s->data_file;
4084 break;
4085
4086 default:
4087 abort();
4088 }
4089 qemu_co_mutex_unlock(&s->lock);
4090 ret = bdrv_co_copy_range_from(child,
4091 copy_offset,
4092 dst, dst_offset,
4093 cur_bytes, read_flags, cur_write_flags);
4094 qemu_co_mutex_lock(&s->lock);
4095 if (ret < 0) {
4096 goto out;
4097 }
4098
4099 bytes -= cur_bytes;
4100 src_offset += cur_bytes;
4101 dst_offset += cur_bytes;
4102 }
4103 ret = 0;
4104
4105out:
4106 qemu_co_mutex_unlock(&s->lock);
4107 return ret;
4108}
4109
4110static int coroutine_fn
4111qcow2_co_copy_range_to(BlockDriverState *bs,
4112 BdrvChild *src, int64_t src_offset,
4113 BdrvChild *dst, int64_t dst_offset,
4114 int64_t bytes, BdrvRequestFlags read_flags,
4115 BdrvRequestFlags write_flags)
4116{
4117 BDRVQcow2State *s = bs->opaque;
4118 int ret;
4119 unsigned int cur_bytes;
4120 uint64_t host_offset;
4121 QCowL2Meta *l2meta = NULL;
4122
4123 assert(!bs->encrypted);
4124
4125 qemu_co_mutex_lock(&s->lock);
4126
4127 while (bytes != 0) {
4128
4129 l2meta = NULL;
4130
4131 cur_bytes = MIN(bytes, INT_MAX);
4132
4133
4134
4135
4136
4137 ret = qcow2_alloc_host_offset(bs, dst_offset, &cur_bytes,
4138 &host_offset, &l2meta);
4139 if (ret < 0) {
4140 goto fail;
4141 }
4142
4143 ret = qcow2_pre_write_overlap_check(bs, 0, host_offset, cur_bytes,
4144 true);
4145 if (ret < 0) {
4146 goto fail;
4147 }
4148
4149 qemu_co_mutex_unlock(&s->lock);
4150 ret = bdrv_co_copy_range_to(src, src_offset, s->data_file, host_offset,
4151 cur_bytes, read_flags, write_flags);
4152 qemu_co_mutex_lock(&s->lock);
4153 if (ret < 0) {
4154 goto fail;
4155 }
4156
4157 ret = qcow2_handle_l2meta(bs, &l2meta, true);
4158 if (ret) {
4159 goto fail;
4160 }
4161
4162 bytes -= cur_bytes;
4163 src_offset += cur_bytes;
4164 dst_offset += cur_bytes;
4165 }
4166 ret = 0;
4167
4168fail:
4169 qcow2_handle_l2meta(bs, &l2meta, false);
4170
4171 qemu_co_mutex_unlock(&s->lock);
4172
4173 trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
4174
4175 return ret;
4176}
4177
4178static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
4179 bool exact, PreallocMode prealloc,
4180 BdrvRequestFlags flags, Error **errp)
4181{
4182 BDRVQcow2State *s = bs->opaque;
4183 uint64_t old_length;
4184 int64_t new_l1_size;
4185 int ret;
4186 QDict *options;
4187
4188 if (prealloc != PREALLOC_MODE_OFF && prealloc != PREALLOC_MODE_METADATA &&
4189 prealloc != PREALLOC_MODE_FALLOC && prealloc != PREALLOC_MODE_FULL)
4190 {
4191 error_setg(errp, "Unsupported preallocation mode '%s'",
4192 PreallocMode_str(prealloc));
4193 return -ENOTSUP;
4194 }
4195
4196 if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {
4197 error_setg(errp, "The new size must be a multiple of %u",
4198 (unsigned) BDRV_SECTOR_SIZE);
4199 return -EINVAL;
4200 }
4201
4202 qemu_co_mutex_lock(&s->lock);
4203
4204
4205
4206
4207
4208 if (s->nb_snapshots && s->qcow_version < 3) {
4209 error_setg(errp, "Can't resize a v2 image which has snapshots");
4210 ret = -ENOTSUP;
4211 goto fail;
4212 }
4213
4214
4215 if (qcow2_truncate_bitmaps_check(bs, errp)) {
4216 ret = -ENOTSUP;
4217 goto fail;
4218 }
4219
4220 old_length = bs->total_sectors * BDRV_SECTOR_SIZE;
4221 new_l1_size = size_to_l1(s, offset);
4222
4223 if (offset < old_length) {
4224 int64_t last_cluster, old_file_size;
4225 if (prealloc != PREALLOC_MODE_OFF) {
4226 error_setg(errp,
4227 "Preallocation can't be used for shrinking an image");
4228 ret = -EINVAL;
4229 goto fail;
4230 }
4231
4232 ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size),
4233 old_length - ROUND_UP(offset,
4234 s->cluster_size),
4235 QCOW2_DISCARD_ALWAYS, true);
4236 if (ret < 0) {
4237 error_setg_errno(errp, -ret, "Failed to discard cropped clusters");
4238 goto fail;
4239 }
4240
4241 ret = qcow2_shrink_l1_table(bs, new_l1_size);
4242 if (ret < 0) {
4243 error_setg_errno(errp, -ret,
4244 "Failed to reduce the number of L2 tables");
4245 goto fail;
4246 }
4247
4248 ret = qcow2_shrink_reftable(bs);
4249 if (ret < 0) {
4250 error_setg_errno(errp, -ret,
4251 "Failed to discard unused refblocks");
4252 goto fail;
4253 }
4254
4255 old_file_size = bdrv_getlength(bs->file->bs);
4256 if (old_file_size < 0) {
4257 error_setg_errno(errp, -old_file_size,
4258 "Failed to inquire current file length");
4259 ret = old_file_size;
4260 goto fail;
4261 }
4262 last_cluster = qcow2_get_last_cluster(bs, old_file_size);
4263 if (last_cluster < 0) {
4264 error_setg_errno(errp, -last_cluster,
4265 "Failed to find the last cluster");
4266 ret = last_cluster;
4267 goto fail;
4268 }
4269 if ((last_cluster + 1) * s->cluster_size < old_file_size) {
4270 Error *local_err = NULL;
4271
4272
4273
4274
4275
4276
4277
4278
4279 bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
4280 false, PREALLOC_MODE_OFF, 0, &local_err);
4281 if (local_err) {
4282 warn_reportf_err(local_err,
4283 "Failed to truncate the tail of the image: ");
4284 }
4285 }
4286 } else {
4287 ret = qcow2_grow_l1_table(bs, new_l1_size, true);
4288 if (ret < 0) {
4289 error_setg_errno(errp, -ret, "Failed to grow the L1 table");
4290 goto fail;
4291 }
4292
4293 if (data_file_is_raw(bs) && prealloc == PREALLOC_MODE_OFF) {
4294
4295
4296
4297
4298
4299
4300
4301
4302 prealloc = PREALLOC_MODE_METADATA;
4303 }
4304 }
4305
4306 switch (prealloc) {
4307 case PREALLOC_MODE_OFF:
4308 if (has_data_file(bs)) {
4309
4310
4311
4312
4313
4314 ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
4315 errp);
4316 if (ret < 0) {
4317 goto fail;
4318 }
4319 }
4320 break;
4321
4322 case PREALLOC_MODE_METADATA:
4323 ret = preallocate_co(bs, old_length, offset, prealloc, errp);
4324 if (ret < 0) {
4325 goto fail;
4326 }
4327 break;
4328
4329 case PREALLOC_MODE_FALLOC:
4330 case PREALLOC_MODE_FULL:
4331 {
4332 int64_t allocation_start, host_offset, guest_offset;
4333 int64_t clusters_allocated;
4334 int64_t old_file_size, last_cluster, new_file_size;
4335 uint64_t nb_new_data_clusters, nb_new_l2_tables;
4336 bool subclusters_need_allocation = false;
4337
4338
4339
4340 if (has_data_file(bs)) {
4341 ret = preallocate_co(bs, old_length, offset, prealloc, errp);
4342 if (ret < 0) {
4343 goto fail;
4344 }
4345 break;
4346 }
4347
4348 old_file_size = bdrv_getlength(bs->file->bs);
4349 if (old_file_size < 0) {
4350 error_setg_errno(errp, -old_file_size,
4351 "Failed to inquire current file length");
4352 ret = old_file_size;
4353 goto fail;
4354 }
4355
4356 last_cluster = qcow2_get_last_cluster(bs, old_file_size);
4357 if (last_cluster >= 0) {
4358 old_file_size = (last_cluster + 1) * s->cluster_size;
4359 } else {
4360 old_file_size = ROUND_UP(old_file_size, s->cluster_size);
4361 }
4362
4363 nb_new_data_clusters = (ROUND_UP(offset, s->cluster_size) -
4364 start_of_cluster(s, old_length)) >> s->cluster_bits;
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376 nb_new_l2_tables = DIV_ROUND_UP(nb_new_data_clusters,
4377 s->cluster_size / l2_entry_size(s));
4378
4379
4380 nb_new_l2_tables++;
4381
4382 allocation_start = qcow2_refcount_area(bs, old_file_size,
4383 nb_new_data_clusters +
4384 nb_new_l2_tables,
4385 true, 0, 0);
4386 if (allocation_start < 0) {
4387 error_setg_errno(errp, -allocation_start,
4388 "Failed to resize refcount structures");
4389 ret = allocation_start;
4390 goto fail;
4391 }
4392
4393 clusters_allocated = qcow2_alloc_clusters_at(bs, allocation_start,
4394 nb_new_data_clusters);
4395 if (clusters_allocated < 0) {
4396 error_setg_errno(errp, -clusters_allocated,
4397 "Failed to allocate data clusters");
4398 ret = clusters_allocated;
4399 goto fail;
4400 }
4401
4402 assert(clusters_allocated == nb_new_data_clusters);
4403
4404
4405 new_file_size = allocation_start +
4406 nb_new_data_clusters * s->cluster_size;
4407
4408
4409
4410
4411
4412
4413 if (flags & BDRV_REQ_ZERO_WRITE) {
4414 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
4415 BDRV_REQ_ZERO_WRITE, NULL);
4416 if (ret >= 0) {
4417 flags &= ~BDRV_REQ_ZERO_WRITE;
4418
4419 subclusters_need_allocation = true;
4420 }
4421 } else {
4422 ret = -1;
4423 }
4424 if (ret < 0) {
4425 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
4426 errp);
4427 }
4428 if (ret < 0) {
4429 error_prepend(errp, "Failed to resize underlying file: ");
4430 qcow2_free_clusters(bs, allocation_start,
4431 nb_new_data_clusters * s->cluster_size,
4432 QCOW2_DISCARD_OTHER);
4433 goto fail;
4434 }
4435
4436
4437 host_offset = allocation_start;
4438 guest_offset = old_length;
4439 while (nb_new_data_clusters) {
4440 int64_t nb_clusters = MIN(
4441 nb_new_data_clusters,
4442 s->l2_slice_size - offset_to_l2_slice_index(s, guest_offset));
4443 unsigned cow_start_length = offset_into_cluster(s, guest_offset);
4444 QCowL2Meta allocation;
4445 guest_offset = start_of_cluster(s, guest_offset);
4446 allocation = (QCowL2Meta) {
4447 .offset = guest_offset,
4448 .alloc_offset = host_offset,
4449 .nb_clusters = nb_clusters,
4450 .cow_start = {
4451 .offset = 0,
4452 .nb_bytes = cow_start_length,
4453 },
4454 .cow_end = {
4455 .offset = nb_clusters << s->cluster_bits,
4456 .nb_bytes = 0,
4457 },
4458 .prealloc = !subclusters_need_allocation,
4459 };
4460 qemu_co_queue_init(&allocation.dependent_requests);
4461
4462 ret = qcow2_alloc_cluster_link_l2(bs, &allocation);
4463 if (ret < 0) {
4464 error_setg_errno(errp, -ret, "Failed to update L2 tables");
4465 qcow2_free_clusters(bs, host_offset,
4466 nb_new_data_clusters * s->cluster_size,
4467 QCOW2_DISCARD_OTHER);
4468 goto fail;
4469 }
4470
4471 guest_offset += nb_clusters * s->cluster_size;
4472 host_offset += nb_clusters * s->cluster_size;
4473 nb_new_data_clusters -= nb_clusters;
4474 }
4475 break;
4476 }
4477
4478 default:
4479 g_assert_not_reached();
4480 }
4481
4482 if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
4483 uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->subcluster_size);
4484
4485
4486
4487
4488
4489
4490 if (offset > zero_start) {
4491 ret = qcow2_subcluster_zeroize(bs, zero_start, offset - zero_start,
4492 0);
4493 if (ret < 0) {
4494 error_setg_errno(errp, -ret, "Failed to zero out new clusters");
4495 goto fail;
4496 }
4497 }
4498
4499
4500 if (zero_start > old_length) {
4501 uint64_t len = MIN(zero_start, offset) - old_length;
4502 uint8_t *buf = qemu_blockalign0(bs, len);
4503 QEMUIOVector qiov;
4504 qemu_iovec_init_buf(&qiov, buf, len);
4505
4506 qemu_co_mutex_unlock(&s->lock);
4507 ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
4508 qemu_co_mutex_lock(&s->lock);
4509
4510 qemu_vfree(buf);
4511 if (ret < 0) {
4512 error_setg_errno(errp, -ret, "Failed to zero out the new area");
4513 goto fail;
4514 }
4515 }
4516 }
4517
4518 if (prealloc != PREALLOC_MODE_OFF) {
4519
4520 ret = qcow2_write_caches(bs);
4521 if (ret < 0) {
4522 error_setg_errno(errp, -ret,
4523 "Failed to flush the preallocated area to disk");
4524 goto fail;
4525 }
4526 }
4527
4528 bs->total_sectors = offset / BDRV_SECTOR_SIZE;
4529
4530
4531 offset = cpu_to_be64(offset);
4532 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
4533 &offset, sizeof(offset));
4534 if (ret < 0) {
4535 error_setg_errno(errp, -ret, "Failed to update the image size");
4536 goto fail;
4537 }
4538
4539 s->l1_vm_state_index = new_l1_size;
4540
4541
4542 options = qdict_clone_shallow(bs->options);
4543 ret = qcow2_update_options(bs, options, s->flags, errp);
4544 qobject_unref(options);
4545 if (ret < 0) {
4546 goto fail;
4547 }
4548 ret = 0;
4549fail:
4550 qemu_co_mutex_unlock(&s->lock);
4551 return ret;
4552}
4553
4554static coroutine_fn int
4555qcow2_co_pwritev_compressed_task(BlockDriverState *bs,
4556 uint64_t offset, uint64_t bytes,
4557 QEMUIOVector *qiov, size_t qiov_offset)
4558{
4559 BDRVQcow2State *s = bs->opaque;
4560 int ret;
4561 ssize_t out_len;
4562 uint8_t *buf, *out_buf;
4563 uint64_t cluster_offset;
4564
4565 assert(bytes == s->cluster_size || (bytes < s->cluster_size &&
4566 (offset + bytes == bs->total_sectors << BDRV_SECTOR_BITS)));
4567
4568 buf = qemu_blockalign(bs, s->cluster_size);
4569 if (bytes < s->cluster_size) {
4570
4571 memset(buf + bytes, 0, s->cluster_size - bytes);
4572 }
4573 qemu_iovec_to_buf(qiov, qiov_offset, buf, bytes);
4574
4575 out_buf = g_malloc(s->cluster_size);
4576
4577 out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1,
4578 buf, s->cluster_size);
4579 if (out_len == -ENOMEM) {
4580
4581 ret = qcow2_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset, 0);
4582 if (ret < 0) {
4583 goto fail;
4584 }
4585 goto success;
4586 } else if (out_len < 0) {
4587 ret = -EINVAL;
4588 goto fail;
4589 }
4590
4591 qemu_co_mutex_lock(&s->lock);
4592 ret = qcow2_alloc_compressed_cluster_offset(bs, offset, out_len,
4593 &cluster_offset);
4594 if (ret < 0) {
4595 qemu_co_mutex_unlock(&s->lock);
4596 goto fail;
4597 }
4598
4599 ret = qcow2_pre_write_overlap_check(bs, 0, cluster_offset, out_len, true);
4600 qemu_co_mutex_unlock(&s->lock);
4601 if (ret < 0) {
4602 goto fail;
4603 }
4604
4605 BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
4606 ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);
4607 if (ret < 0) {
4608 goto fail;
4609 }
4610success:
4611 ret = 0;
4612fail:
4613 qemu_vfree(buf);
4614 g_free(out_buf);
4615 return ret;
4616}
4617
4618static coroutine_fn int qcow2_co_pwritev_compressed_task_entry(AioTask *task)
4619{
4620 Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);
4621
4622 assert(!t->subcluster_type && !t->l2meta);
4623
4624 return qcow2_co_pwritev_compressed_task(t->bs, t->offset, t->bytes, t->qiov,
4625 t->qiov_offset);
4626}
4627
4628
4629
4630
4631
4632static coroutine_fn int
4633qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
4634 int64_t offset, int64_t bytes,
4635 QEMUIOVector *qiov, size_t qiov_offset)
4636{
4637 BDRVQcow2State *s = bs->opaque;
4638 AioTaskPool *aio = NULL;
4639 int ret = 0;
4640
4641 if (has_data_file(bs)) {
4642 return -ENOTSUP;
4643 }
4644
4645 if (bytes == 0) {
4646
4647
4648
4649
4650 int64_t len = bdrv_getlength(bs->file->bs);
4651 if (len < 0) {
4652 return len;
4653 }
4654 return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
4655 NULL);
4656 }
4657
4658 if (offset_into_cluster(s, offset)) {
4659 return -EINVAL;
4660 }
4661
4662 if (offset_into_cluster(s, bytes) &&
4663 (offset + bytes) != (bs->total_sectors << BDRV_SECTOR_BITS)) {
4664 return -EINVAL;
4665 }
4666
4667 while (bytes && aio_task_pool_status(aio) == 0) {
4668 uint64_t chunk_size = MIN(bytes, s->cluster_size);
4669
4670 if (!aio && chunk_size != bytes) {
4671 aio = aio_task_pool_new(QCOW2_MAX_WORKERS);
4672 }
4673
4674 ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_compressed_task_entry,
4675 0, 0, offset, chunk_size, qiov, qiov_offset, NULL);
4676 if (ret < 0) {
4677 break;
4678 }
4679 qiov_offset += chunk_size;
4680 offset += chunk_size;
4681 bytes -= chunk_size;
4682 }
4683
4684 if (aio) {
4685 aio_task_pool_wait_all(aio);
4686 if (ret == 0) {
4687 ret = aio_task_pool_status(aio);
4688 }
4689 g_free(aio);
4690 }
4691
4692 return ret;
4693}
4694
4695static int coroutine_fn
4696qcow2_co_preadv_compressed(BlockDriverState *bs,
4697 uint64_t l2_entry,
4698 uint64_t offset,
4699 uint64_t bytes,
4700 QEMUIOVector *qiov,
4701 size_t qiov_offset)
4702{
4703 BDRVQcow2State *s = bs->opaque;
4704 int ret = 0, csize;
4705 uint64_t coffset;
4706 uint8_t *buf, *out_buf;
4707 int offset_in_cluster = offset_into_cluster(s, offset);
4708
4709 qcow2_parse_compressed_l2_entry(bs, l2_entry, &coffset, &csize);
4710
4711 buf = g_try_malloc(csize);
4712 if (!buf) {
4713 return -ENOMEM;
4714 }
4715
4716 out_buf = qemu_blockalign(bs, s->cluster_size);
4717
4718 BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
4719 ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);
4720 if (ret < 0) {
4721 goto fail;
4722 }
4723
4724 if (qcow2_co_decompress(bs, out_buf, s->cluster_size, buf, csize) < 0) {
4725 ret = -EIO;
4726 goto fail;
4727 }
4728
4729 qemu_iovec_from_buf(qiov, qiov_offset, out_buf + offset_in_cluster, bytes);
4730
4731fail:
4732 qemu_vfree(out_buf);
4733 g_free(buf);
4734
4735 return ret;
4736}
4737
4738static int make_completely_empty(BlockDriverState *bs)
4739{
4740 BDRVQcow2State *s = bs->opaque;
4741 Error *local_err = NULL;
4742 int ret, l1_clusters;
4743 int64_t offset;
4744 uint64_t *new_reftable = NULL;
4745 uint64_t rt_entry, l1_size2;
4746 struct {
4747 uint64_t l1_offset;
4748 uint64_t reftable_offset;
4749 uint32_t reftable_clusters;
4750 } QEMU_PACKED l1_ofs_rt_ofs_cls;
4751
4752 ret = qcow2_cache_empty(bs, s->l2_table_cache);
4753 if (ret < 0) {
4754 goto fail;
4755 }
4756
4757 ret = qcow2_cache_empty(bs, s->refcount_block_cache);
4758 if (ret < 0) {
4759 goto fail;
4760 }
4761
4762
4763 ret = qcow2_mark_dirty(bs);
4764 if (ret < 0) {
4765 goto fail;
4766 }
4767
4768 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4769
4770 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE);
4771 l1_size2 = (uint64_t)s->l1_size * L1E_SIZE;
4772
4773
4774
4775
4776 ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset,
4777 l1_clusters * s->cluster_size, 0);
4778 if (ret < 0) {
4779 goto fail_broken_refcounts;
4780 }
4781 memset(s->l1_table, 0, l1_size2);
4782
4783 BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE);
4784
4785
4786
4787
4788
4789
4790 ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size,
4791 (2 + l1_clusters) * s->cluster_size, 0);
4792
4793
4794
4795
4796 if (ret < 0) {
4797 goto fail_broken_refcounts;
4798 }
4799
4800 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
4801 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE);
4802
4803
4804
4805
4806 l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size);
4807 l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
4808 l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
4809 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
4810 &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
4811 if (ret < 0) {
4812 goto fail_broken_refcounts;
4813 }
4814
4815 s->l1_table_offset = 3 * s->cluster_size;
4816
4817 new_reftable = g_try_new0(uint64_t, s->cluster_size / REFTABLE_ENTRY_SIZE);
4818 if (!new_reftable) {
4819 ret = -ENOMEM;
4820 goto fail_broken_refcounts;
4821 }
4822
4823 s->refcount_table_offset = s->cluster_size;
4824 s->refcount_table_size = s->cluster_size / REFTABLE_ENTRY_SIZE;
4825 s->max_refcount_table_index = 0;
4826
4827 g_free(s->refcount_table);
4828 s->refcount_table = new_reftable;
4829 new_reftable = NULL;
4830
4831
4832
4833
4834
4835
4836
4837 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
4838
4839
4840 rt_entry = cpu_to_be64(2 * s->cluster_size);
4841 ret = bdrv_pwrite_sync(bs->file, s->cluster_size,
4842 &rt_entry, sizeof(rt_entry));
4843 if (ret < 0) {
4844 goto fail_broken_refcounts;
4845 }
4846 s->refcount_table[0] = 2 * s->cluster_size;
4847
4848 s->free_cluster_index = 0;
4849 assert(3 + l1_clusters <= s->refcount_block_size);
4850 offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2);
4851 if (offset < 0) {
4852 ret = offset;
4853 goto fail_broken_refcounts;
4854 } else if (offset > 0) {
4855 error_report("First cluster in emptied image is in use");
4856 abort();
4857 }
4858
4859
4860
4861 ret = qcow2_mark_clean(bs);
4862 if (ret < 0) {
4863 goto fail;
4864 }
4865
4866 ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
4867 PREALLOC_MODE_OFF, 0, &local_err);
4868 if (ret < 0) {
4869 error_report_err(local_err);
4870 goto fail;
4871 }
4872
4873 return 0;
4874
4875fail_broken_refcounts:
4876
4877
4878
4879
4880
4881
4882 bs->drv = NULL;
4883
4884fail:
4885 g_free(new_reftable);
4886 return ret;
4887}
4888
4889static int qcow2_make_empty(BlockDriverState *bs)
4890{
4891 BDRVQcow2State *s = bs->opaque;
4892 uint64_t offset, end_offset;
4893 int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size);
4894 int l1_clusters, ret = 0;
4895
4896 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE);
4897
4898 if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps &&
4899 3 + l1_clusters <= s->refcount_block_size &&
4900 s->crypt_method_header != QCOW_CRYPT_LUKS &&
4901 !has_data_file(bs)) {
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911 return make_completely_empty(bs);
4912 }
4913
4914
4915
4916 end_offset = bs->total_sectors * BDRV_SECTOR_SIZE;
4917 for (offset = 0; offset < end_offset; offset += step) {
4918
4919
4920
4921
4922
4923 ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset),
4924 QCOW2_DISCARD_SNAPSHOT, true);
4925 if (ret < 0) {
4926 break;
4927 }
4928 }
4929
4930 return ret;
4931}
4932
4933static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
4934{
4935 BDRVQcow2State *s = bs->opaque;
4936 int ret;
4937
4938 qemu_co_mutex_lock(&s->lock);
4939 ret = qcow2_write_caches(bs);
4940 qemu_co_mutex_unlock(&s->lock);
4941
4942 return ret;
4943}
4944
4945static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
4946 Error **errp)
4947{
4948 Error *local_err = NULL;
4949 BlockMeasureInfo *info;
4950 uint64_t required = 0;
4951 uint64_t virtual_size;
4952 uint64_t refcount_bits;
4953 uint64_t l2_tables;
4954 uint64_t luks_payload_size = 0;
4955 size_t cluster_size;
4956 int version;
4957 char *optstr;
4958 PreallocMode prealloc;
4959 bool has_backing_file;
4960 bool has_luks;
4961 bool extended_l2;
4962 size_t l2e_size;
4963
4964
4965 extended_l2 = qemu_opt_get_bool_del(opts, BLOCK_OPT_EXTL2, false);
4966
4967 cluster_size = qcow2_opt_get_cluster_size_del(opts, extended_l2,
4968 &local_err);
4969 if (local_err) {
4970 goto err;
4971 }
4972
4973 version = qcow2_opt_get_version_del(opts, &local_err);
4974 if (local_err) {
4975 goto err;
4976 }
4977
4978 refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
4979 if (local_err) {
4980 goto err;
4981 }
4982
4983 optstr = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
4984 prealloc = qapi_enum_parse(&PreallocMode_lookup, optstr,
4985 PREALLOC_MODE_OFF, &local_err);
4986 g_free(optstr);
4987 if (local_err) {
4988 goto err;
4989 }
4990
4991 optstr = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
4992 has_backing_file = !!optstr;
4993 g_free(optstr);
4994
4995 optstr = qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT_FORMAT);
4996 has_luks = optstr && strcmp(optstr, "luks") == 0;
4997 g_free(optstr);
4998
4999 if (has_luks) {
5000 g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
5001 QDict *cryptoopts = qcow2_extract_crypto_opts(opts, "luks", errp);
5002 size_t headerlen;
5003
5004 create_opts = block_crypto_create_opts_init(cryptoopts, errp);
5005 qobject_unref(cryptoopts);
5006 if (!create_opts) {
5007 goto err;
5008 }
5009
5010 if (!qcrypto_block_calculate_payload_offset(create_opts,
5011 "encrypt.",
5012 &headerlen,
5013 &local_err)) {
5014 goto err;
5015 }
5016
5017 luks_payload_size = ROUND_UP(headerlen, cluster_size);
5018 }
5019
5020 virtual_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
5021 virtual_size = ROUND_UP(virtual_size, cluster_size);
5022
5023
5024 l2e_size = extended_l2 ? L2E_SIZE_EXTENDED : L2E_SIZE_NORMAL;
5025 l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
5026 cluster_size / l2e_size);
5027 if (l2_tables * L1E_SIZE > QCOW_MAX_L1_SIZE) {
5028 error_setg(&local_err, "The image size is too large "
5029 "(try using a larger cluster size)");
5030 goto err;
5031 }
5032
5033
5034 if (in_bs) {
5035 int64_t ssize = bdrv_getlength(in_bs);
5036 if (ssize < 0) {
5037 error_setg_errno(&local_err, -ssize,
5038 "Unable to get image virtual_size");
5039 goto err;
5040 }
5041
5042 virtual_size = ROUND_UP(ssize, cluster_size);
5043
5044 if (has_backing_file) {
5045
5046
5047
5048
5049
5050 required = virtual_size;
5051 } else {
5052 int64_t offset;
5053 int64_t pnum = 0;
5054
5055 for (offset = 0; offset < ssize; offset += pnum) {
5056 int ret;
5057
5058 ret = bdrv_block_status_above(in_bs, NULL, offset,
5059 ssize - offset, &pnum, NULL,
5060 NULL);
5061 if (ret < 0) {
5062 error_setg_errno(&local_err, -ret,
5063 "Unable to get block status");
5064 goto err;
5065 }
5066
5067 if (ret & BDRV_BLOCK_ZERO) {
5068
5069 } else if ((ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) ==
5070 (BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED)) {
5071
5072 pnum = ROUND_UP(offset + pnum, cluster_size) - offset;
5073
5074
5075 required += offset % cluster_size + pnum;
5076 }
5077 }
5078 }
5079 }
5080
5081
5082
5083
5084 if (prealloc == PREALLOC_MODE_FULL || prealloc == PREALLOC_MODE_FALLOC) {
5085 required = virtual_size;
5086 }
5087
5088 info = g_new0(BlockMeasureInfo, 1);
5089 info->fully_allocated = luks_payload_size +
5090 qcow2_calc_prealloc_size(virtual_size, cluster_size,
5091 ctz32(refcount_bits), extended_l2);
5092
5093
5094
5095
5096
5097
5098
5099 info->required = info->fully_allocated - virtual_size + required;
5100 info->has_bitmaps = version >= 3 && in_bs &&
5101 bdrv_supports_persistent_dirty_bitmap(in_bs);
5102 if (info->has_bitmaps) {
5103 info->bitmaps = qcow2_get_persistent_dirty_bitmap_size(in_bs,
5104 cluster_size);
5105 }
5106 return info;
5107
5108err:
5109 error_propagate(errp, local_err);
5110 return NULL;
5111}
5112
5113static int qcow2_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
5114{
5115 BDRVQcow2State *s = bs->opaque;
5116 bdi->cluster_size = s->cluster_size;
5117 bdi->vm_state_offset = qcow2_vm_state_offset(s);
5118 bdi->is_dirty = s->incompatible_features & QCOW2_INCOMPAT_DIRTY;
5119 return 0;
5120}
5121
5122static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
5123 Error **errp)
5124{
5125 BDRVQcow2State *s = bs->opaque;
5126 ImageInfoSpecific *spec_info;
5127 QCryptoBlockInfo *encrypt_info = NULL;
5128
5129 if (s->crypto != NULL) {
5130 encrypt_info = qcrypto_block_get_info(s->crypto, errp);
5131 if (!encrypt_info) {
5132 return NULL;
5133 }
5134 }
5135
5136 spec_info = g_new(ImageInfoSpecific, 1);
5137 *spec_info = (ImageInfoSpecific){
5138 .type = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
5139 .u.qcow2.data = g_new0(ImageInfoSpecificQCow2, 1),
5140 };
5141 if (s->qcow_version == 2) {
5142 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
5143 .compat = g_strdup("0.10"),
5144 .refcount_bits = s->refcount_bits,
5145 };
5146 } else if (s->qcow_version == 3) {
5147 Qcow2BitmapInfoList *bitmaps;
5148 if (!qcow2_get_bitmap_info_list(bs, &bitmaps, errp)) {
5149 qapi_free_ImageInfoSpecific(spec_info);
5150 qapi_free_QCryptoBlockInfo(encrypt_info);
5151 return NULL;
5152 }
5153 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){
5154 .compat = g_strdup("1.1"),
5155 .lazy_refcounts = s->compatible_features &
5156 QCOW2_COMPAT_LAZY_REFCOUNTS,
5157 .has_lazy_refcounts = true,
5158 .corrupt = s->incompatible_features &
5159 QCOW2_INCOMPAT_CORRUPT,
5160 .has_corrupt = true,
5161 .has_extended_l2 = true,
5162 .extended_l2 = has_subclusters(s),
5163 .refcount_bits = s->refcount_bits,
5164 .has_bitmaps = !!bitmaps,
5165 .bitmaps = bitmaps,
5166 .has_data_file = !!s->image_data_file,
5167 .data_file = g_strdup(s->image_data_file),
5168 .has_data_file_raw = has_data_file(bs),
5169 .data_file_raw = data_file_is_raw(bs),
5170 .compression_type = s->compression_type,
5171 };
5172 } else {
5173
5174
5175 assert(false);
5176 }
5177
5178 if (encrypt_info) {
5179 ImageInfoSpecificQCow2Encryption *qencrypt =
5180 g_new(ImageInfoSpecificQCow2Encryption, 1);
5181 switch (encrypt_info->format) {
5182 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
5183 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES;
5184 break;
5185 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
5186 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS;
5187 qencrypt->u.luks = encrypt_info->u.luks;
5188 break;
5189 default:
5190 abort();
5191 }
5192
5193
5194 memset(&encrypt_info->u, 0, sizeof(encrypt_info->u));
5195 qapi_free_QCryptoBlockInfo(encrypt_info);
5196
5197 spec_info->u.qcow2.data->has_encrypt = true;
5198 spec_info->u.qcow2.data->encrypt = qencrypt;
5199 }
5200
5201 return spec_info;
5202}
5203
5204static int qcow2_has_zero_init(BlockDriverState *bs)
5205{
5206 BDRVQcow2State *s = bs->opaque;
5207 bool preallocated;
5208
5209 if (qemu_in_coroutine()) {
5210 qemu_co_mutex_lock(&s->lock);
5211 }
5212
5213
5214
5215
5216
5217 preallocated = s->l1_size > 0 && s->l1_table[0] != 0;
5218 if (qemu_in_coroutine()) {
5219 qemu_co_mutex_unlock(&s->lock);
5220 }
5221
5222 if (!preallocated) {
5223 return 1;
5224 } else if (bs->encrypted) {
5225 return 0;
5226 } else {
5227 return bdrv_has_zero_init(s->data_file->bs);
5228 }
5229}
5230
5231
5232
5233
5234
5235static int64_t qcow2_check_vmstate_request(BlockDriverState *bs,
5236 QEMUIOVector *qiov, int64_t pos)
5237{
5238 BDRVQcow2State *s = bs->opaque;
5239 int64_t vmstate_offset = qcow2_vm_state_offset(s);
5240 int ret;
5241
5242
5243 bdrv_check_qiov_request(pos, qiov->size, qiov, 0, &error_abort);
5244
5245 if (INT64_MAX - pos < vmstate_offset) {
5246 return -EIO;
5247 }
5248
5249 pos += vmstate_offset;
5250 ret = bdrv_check_qiov_request(pos, qiov->size, qiov, 0, NULL);
5251 if (ret < 0) {
5252 return ret;
5253 }
5254
5255 return pos;
5256}
5257
5258static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
5259 int64_t pos)
5260{
5261 int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
5262 if (offset < 0) {
5263 return offset;
5264 }
5265
5266 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
5267 return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0);
5268}
5269
5270static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
5271 int64_t pos)
5272{
5273 int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
5274 if (offset < 0) {
5275 return offset;
5276 }
5277
5278 BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
5279 return bs->drv->bdrv_co_preadv_part(bs, offset, qiov->size, qiov, 0, 0);
5280}
5281
5282
5283
5284
5285
5286static int qcow2_downgrade(BlockDriverState *bs, int target_version,
5287 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5288 Error **errp)
5289{
5290 BDRVQcow2State *s = bs->opaque;
5291 int current_version = s->qcow_version;
5292 int ret;
5293 int i;
5294
5295
5296 assert(target_version < current_version);
5297
5298
5299 assert(target_version == 2);
5300
5301 if (s->refcount_order != 4) {
5302 error_setg(errp, "compat=0.10 requires refcount_bits=16");
5303 return -ENOTSUP;
5304 }
5305
5306 if (has_data_file(bs)) {
5307 error_setg(errp, "Cannot downgrade an image with a data file");
5308 return -ENOTSUP;
5309 }
5310
5311
5312
5313
5314
5315
5316
5317
5318 for (i = 0; i < s->nb_snapshots; i++) {
5319 if (s->snapshots[i].vm_state_size > UINT32_MAX ||
5320 s->snapshots[i].disk_size != bs->total_sectors * BDRV_SECTOR_SIZE) {
5321 error_setg(errp, "Internal snapshots prevent downgrade of image");
5322 return -ENOTSUP;
5323 }
5324 }
5325
5326
5327 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) {
5328 ret = qcow2_mark_clean(bs);
5329 if (ret < 0) {
5330 error_setg_errno(errp, -ret, "Failed to make the image clean");
5331 return ret;
5332 }
5333 }
5334
5335
5336
5337
5338
5339 if (s->incompatible_features) {
5340 error_setg(errp, "Cannot downgrade an image with incompatible features "
5341 "%#" PRIx64 " set", s->incompatible_features);
5342 return -ENOTSUP;
5343 }
5344
5345
5346 s->compatible_features = 0;
5347
5348
5349
5350
5351 s->autoclear_features = 0;
5352
5353 ret = qcow2_expand_zero_clusters(bs, status_cb, cb_opaque);
5354 if (ret < 0) {
5355 error_setg_errno(errp, -ret, "Failed to turn zero into data clusters");
5356 return ret;
5357 }
5358
5359 s->qcow_version = target_version;
5360 ret = qcow2_update_header(bs);
5361 if (ret < 0) {
5362 s->qcow_version = current_version;
5363 error_setg_errno(errp, -ret, "Failed to update the image header");
5364 return ret;
5365 }
5366 return 0;
5367}
5368
5369
5370
5371
5372
5373
5374static int qcow2_upgrade(BlockDriverState *bs, int target_version,
5375 BlockDriverAmendStatusCB *status_cb, void *cb_opaque,
5376 Error **errp)
5377{
5378 BDRVQcow2State *s = bs->opaque;
5379 bool need_snapshot_update;
5380 int current_version = s->qcow_version;
5381 int i;
5382 int ret;
5383
5384
5385 assert(target_version > current_version);
5386
5387
5388 assert(target_version == 3);
5389
5390 status_cb(bs, 0, 2, cb_opaque);
5391
5392
5393
5394
5395
5396
5397
5398
5399 need_snapshot_update = false;
5400 for (i = 0; i < s->nb_snapshots; i++) {
5401 if (s->snapshots[i].extra_data_size <
5402 sizeof_field(QCowSnapshotExtraData, vm_state_size_large) +
5403 sizeof_field(QCowSnapshotExtraData, disk_size))
5404 {
5405 need_snapshot_update = true;
5406 break;
5407 }
5408 }
5409 if (need_snapshot_update) {
5410 ret = qcow2_write_snapshots(bs);
5411 if (ret < 0) {
5412 error_setg_errno(errp, -ret, "Failed to update the snapshot table");
5413 return ret;
5414 }
5415 }
5416 status_cb(bs, 1, 2, cb_opaque);
5417
5418 s->qcow_version = target_version;
5419 ret = qcow2_update_header(bs);
5420 if (ret < 0) {
5421 s->qcow_version = current_version;
5422 error_setg_errno(errp, -ret, "Failed to update the image header");
5423 return ret;
5424 }
5425 status_cb(bs, 2, 2, cb_opaque);
5426
5427 return 0;
5428}
5429
5430typedef enum Qcow2AmendOperation {
5431
5432
5433
5434 QCOW2_NO_OPERATION = 0,
5435
5436 QCOW2_UPGRADING,
5437 QCOW2_UPDATING_ENCRYPTION,
5438 QCOW2_CHANGING_REFCOUNT_ORDER,
5439 QCOW2_DOWNGRADING,
5440} Qcow2AmendOperation;
5441
5442typedef struct Qcow2AmendHelperCBInfo {
5443
5444
5445 BlockDriverAmendStatusCB *original_status_cb;
5446 void *original_cb_opaque;
5447
5448 Qcow2AmendOperation current_operation;
5449
5450
5451 int total_operations;
5452
5453
5454
5455
5456 int operations_completed;
5457
5458
5459 int64_t offset_completed;
5460
5461 Qcow2AmendOperation last_operation;
5462 int64_t last_work_size;
5463} Qcow2AmendHelperCBInfo;
5464
5465static void qcow2_amend_helper_cb(BlockDriverState *bs,
5466 int64_t operation_offset,
5467 int64_t operation_work_size, void *opaque)
5468{
5469 Qcow2AmendHelperCBInfo *info = opaque;
5470 int64_t current_work_size;
5471 int64_t projected_work_size;
5472
5473 if (info->current_operation != info->last_operation) {
5474 if (info->last_operation != QCOW2_NO_OPERATION) {
5475 info->offset_completed += info->last_work_size;
5476 info->operations_completed++;
5477 }
5478
5479 info->last_operation = info->current_operation;
5480 }
5481
5482 assert(info->total_operations > 0);
5483 assert(info->operations_completed < info->total_operations);
5484
5485 info->last_work_size = operation_work_size;
5486
5487 current_work_size = info->offset_completed + operation_work_size;
5488
5489
5490
5491
5492
5493 projected_work_size = current_work_size * (info->total_operations -
5494 info->operations_completed - 1)
5495 / (info->operations_completed + 1);
5496
5497 info->original_status_cb(bs, info->offset_completed + operation_offset,
5498 current_work_size + projected_work_size,
5499 info->original_cb_opaque);
5500}
5501
5502static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
5503 BlockDriverAmendStatusCB *status_cb,
5504 void *cb_opaque,
5505 bool force,
5506 Error **errp)
5507{
5508 BDRVQcow2State *s = bs->opaque;
5509 int old_version = s->qcow_version, new_version = old_version;
5510 uint64_t new_size = 0;
5511 const char *backing_file = NULL, *backing_format = NULL, *data_file = NULL;
5512 bool lazy_refcounts = s->use_lazy_refcounts;
5513 bool data_file_raw = data_file_is_raw(bs);
5514 const char *compat = NULL;
5515 int refcount_bits = s->refcount_bits;
5516 int ret;
5517 QemuOptDesc *desc = opts->list->desc;
5518 Qcow2AmendHelperCBInfo helper_cb_info;
5519 bool encryption_update = false;
5520
5521 while (desc && desc->name) {
5522 if (!qemu_opt_find(opts, desc->name)) {
5523
5524 desc++;
5525 continue;
5526 }
5527
5528 if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) {
5529 compat = qemu_opt_get(opts, BLOCK_OPT_COMPAT_LEVEL);
5530 if (!compat) {
5531
5532 } else if (!strcmp(compat, "0.10") || !strcmp(compat, "v2")) {
5533 new_version = 2;
5534 } else if (!strcmp(compat, "1.1") || !strcmp(compat, "v3")) {
5535 new_version = 3;
5536 } else {
5537 error_setg(errp, "Unknown compatibility level %s", compat);
5538 return -EINVAL;
5539 }
5540 } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) {
5541 new_size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);
5542 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) {
5543 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);
5544 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) {
5545 backing_format = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);
5546 } else if (g_str_has_prefix(desc->name, "encrypt.")) {
5547 if (!s->crypto) {
5548 error_setg(errp,
5549 "Can't amend encryption options - encryption not present");
5550 return -EINVAL;
5551 }
5552 if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
5553 error_setg(errp,
5554 "Only LUKS encryption options can be amended");
5555 return -ENOTSUP;
5556 }
5557 encryption_update = true;
5558 } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) {
5559 lazy_refcounts = qemu_opt_get_bool(opts, BLOCK_OPT_LAZY_REFCOUNTS,
5560 lazy_refcounts);
5561 } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) {
5562 refcount_bits = qemu_opt_get_number(opts, BLOCK_OPT_REFCOUNT_BITS,
5563 refcount_bits);
5564
5565 if (refcount_bits <= 0 || refcount_bits > 64 ||
5566 !is_power_of_2(refcount_bits))
5567 {
5568 error_setg(errp, "Refcount width must be a power of two and "
5569 "may not exceed 64 bits");
5570 return -EINVAL;
5571 }
5572 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE)) {
5573 data_file = qemu_opt_get(opts, BLOCK_OPT_DATA_FILE);
5574 if (data_file && !has_data_file(bs)) {
5575 error_setg(errp, "data-file can only be set for images that "
5576 "use an external data file");
5577 return -EINVAL;
5578 }
5579 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE_RAW)) {
5580 data_file_raw = qemu_opt_get_bool(opts, BLOCK_OPT_DATA_FILE_RAW,
5581 data_file_raw);
5582 if (data_file_raw && !data_file_is_raw(bs)) {
5583 error_setg(errp, "data-file-raw cannot be set on existing "
5584 "images");
5585 return -EINVAL;
5586 }
5587 } else {
5588
5589
5590 abort();
5591 }
5592
5593 desc++;
5594 }
5595
5596 helper_cb_info = (Qcow2AmendHelperCBInfo){
5597 .original_status_cb = status_cb,
5598 .original_cb_opaque = cb_opaque,
5599 .total_operations = (new_version != old_version)
5600 + (s->refcount_bits != refcount_bits) +
5601 (encryption_update == true)
5602 };
5603
5604
5605 if (new_version > old_version) {
5606 helper_cb_info.current_operation = QCOW2_UPGRADING;
5607 ret = qcow2_upgrade(bs, new_version, &qcow2_amend_helper_cb,
5608 &helper_cb_info, errp);
5609 if (ret < 0) {
5610 return ret;
5611 }
5612 }
5613
5614 if (encryption_update) {
5615 QDict *amend_opts_dict;
5616 QCryptoBlockAmendOptions *amend_opts;
5617
5618 helper_cb_info.current_operation = QCOW2_UPDATING_ENCRYPTION;
5619 amend_opts_dict = qcow2_extract_crypto_opts(opts, "luks", errp);
5620 if (!amend_opts_dict) {
5621 return -EINVAL;
5622 }
5623 amend_opts = block_crypto_amend_opts_init(amend_opts_dict, errp);
5624 qobject_unref(amend_opts_dict);
5625 if (!amend_opts) {
5626 return -EINVAL;
5627 }
5628 ret = qcrypto_block_amend_options(s->crypto,
5629 qcow2_crypto_hdr_read_func,
5630 qcow2_crypto_hdr_write_func,
5631 bs,
5632 amend_opts,
5633 force,
5634 errp);
5635 qapi_free_QCryptoBlockAmendOptions(amend_opts);
5636 if (ret < 0) {
5637 return ret;
5638 }
5639 }
5640
5641 if (s->refcount_bits != refcount_bits) {
5642 int refcount_order = ctz32(refcount_bits);
5643
5644 if (new_version < 3 && refcount_bits != 16) {
5645 error_setg(errp, "Refcount widths other than 16 bits require "
5646 "compatibility level 1.1 or above (use compat=1.1 or "
5647 "greater)");
5648 return -EINVAL;
5649 }
5650
5651 helper_cb_info.current_operation = QCOW2_CHANGING_REFCOUNT_ORDER;
5652 ret = qcow2_change_refcount_order(bs, refcount_order,
5653 &qcow2_amend_helper_cb,
5654 &helper_cb_info, errp);
5655 if (ret < 0) {
5656 return ret;
5657 }
5658 }
5659
5660
5661 if (data_file_raw) {
5662 s->autoclear_features |= QCOW2_AUTOCLEAR_DATA_FILE_RAW;
5663 } else {
5664 s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW;
5665 }
5666
5667 if (data_file) {
5668 g_free(s->image_data_file);
5669 s->image_data_file = *data_file ? g_strdup(data_file) : NULL;
5670 }
5671
5672 ret = qcow2_update_header(bs);
5673 if (ret < 0) {
5674 error_setg_errno(errp, -ret, "Failed to update the image header");
5675 return ret;
5676 }
5677
5678 if (backing_file || backing_format) {
5679 if (g_strcmp0(backing_file, s->image_backing_file) ||
5680 g_strcmp0(backing_format, s->image_backing_format)) {
5681 error_setg(errp, "Cannot amend the backing file");
5682 error_append_hint(errp,
5683 "You can use 'qemu-img rebase' instead.\n");
5684 return -EINVAL;
5685 }
5686 }
5687
5688 if (s->use_lazy_refcounts != lazy_refcounts) {
5689 if (lazy_refcounts) {
5690 if (new_version < 3) {
5691 error_setg(errp, "Lazy refcounts only supported with "
5692 "compatibility level 1.1 and above (use compat=1.1 "
5693 "or greater)");
5694 return -EINVAL;
5695 }
5696 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
5697 ret = qcow2_update_header(bs);
5698 if (ret < 0) {
5699 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
5700 error_setg_errno(errp, -ret, "Failed to update the image header");
5701 return ret;
5702 }
5703 s->use_lazy_refcounts = true;
5704 } else {
5705
5706 ret = qcow2_mark_clean(bs);
5707 if (ret < 0) {
5708 error_setg_errno(errp, -ret, "Failed to make the image clean");
5709 return ret;
5710 }
5711
5712 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS;
5713 ret = qcow2_update_header(bs);
5714 if (ret < 0) {
5715 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS;
5716 error_setg_errno(errp, -ret, "Failed to update the image header");
5717 return ret;
5718 }
5719 s->use_lazy_refcounts = false;
5720 }
5721 }
5722
5723 if (new_size) {
5724 BlockBackend *blk = blk_new_with_bs(bs, BLK_PERM_RESIZE, BLK_PERM_ALL,
5725 errp);
5726 if (!blk) {
5727 return -EPERM;
5728 }
5729
5730
5731
5732
5733
5734 ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
5735 blk_unref(blk);
5736 if (ret < 0) {
5737 return ret;
5738 }
5739 }
5740
5741
5742 if (new_version < old_version) {
5743 helper_cb_info.current_operation = QCOW2_DOWNGRADING;
5744 ret = qcow2_downgrade(bs, new_version, &qcow2_amend_helper_cb,
5745 &helper_cb_info, errp);
5746 if (ret < 0) {
5747 return ret;
5748 }
5749 }
5750
5751 return 0;
5752}
5753
5754static int coroutine_fn qcow2_co_amend(BlockDriverState *bs,
5755 BlockdevAmendOptions *opts,
5756 bool force,
5757 Error **errp)
5758{
5759 BlockdevAmendOptionsQcow2 *qopts = &opts->u.qcow2;
5760 BDRVQcow2State *s = bs->opaque;
5761 int ret = 0;
5762
5763 if (qopts->has_encrypt) {
5764 if (!s->crypto) {
5765 error_setg(errp, "image is not encrypted, can't amend");
5766 return -EOPNOTSUPP;
5767 }
5768
5769 if (qopts->encrypt->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
5770 error_setg(errp,
5771 "Amend can't be used to change the qcow2 encryption format");
5772 return -EOPNOTSUPP;
5773 }
5774
5775 if (s->crypt_method_header != QCOW_CRYPT_LUKS) {
5776 error_setg(errp,
5777 "Only LUKS encryption options can be amended for qcow2 with blockdev-amend");
5778 return -EOPNOTSUPP;
5779 }
5780
5781 ret = qcrypto_block_amend_options(s->crypto,
5782 qcow2_crypto_hdr_read_func,
5783 qcow2_crypto_hdr_write_func,
5784 bs,
5785 qopts->encrypt,
5786 force,
5787 errp);
5788 }
5789 return ret;
5790}
5791
5792
5793
5794
5795
5796
5797
5798void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
5799 int64_t size, const char *message_format, ...)
5800{
5801 BDRVQcow2State *s = bs->opaque;
5802 const char *node_name;
5803 char *message;
5804 va_list ap;
5805
5806 fatal = fatal && bdrv_is_writable(bs);
5807
5808 if (s->signaled_corruption &&
5809 (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT)))
5810 {
5811 return;
5812 }
5813
5814 va_start(ap, message_format);
5815 message = g_strdup_vprintf(message_format, ap);
5816 va_end(ap);
5817
5818 if (fatal) {
5819 fprintf(stderr, "qcow2: Marking image as corrupt: %s; further "
5820 "corruption events will be suppressed\n", message);
5821 } else {
5822 fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal "
5823 "corruption events will be suppressed\n", message);
5824 }
5825
5826 node_name = bdrv_get_node_name(bs);
5827 qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
5828 *node_name != '\0', node_name,
5829 message, offset >= 0, offset,
5830 size >= 0, size,
5831 fatal);
5832 g_free(message);
5833
5834 if (fatal) {
5835 qcow2_mark_corrupt(bs);
5836 bs->drv = NULL;
5837 }
5838
5839 s->signaled_corruption = true;
5840}
5841
5842#define QCOW_COMMON_OPTIONS \
5843 { \
5844 .name = BLOCK_OPT_SIZE, \
5845 .type = QEMU_OPT_SIZE, \
5846 .help = "Virtual disk size" \
5847 }, \
5848 { \
5849 .name = BLOCK_OPT_COMPAT_LEVEL, \
5850 .type = QEMU_OPT_STRING, \
5851 .help = "Compatibility level (v2 [0.10] or v3 [1.1])" \
5852 }, \
5853 { \
5854 .name = BLOCK_OPT_BACKING_FILE, \
5855 .type = QEMU_OPT_STRING, \
5856 .help = "File name of a base image" \
5857 }, \
5858 { \
5859 .name = BLOCK_OPT_BACKING_FMT, \
5860 .type = QEMU_OPT_STRING, \
5861 .help = "Image format of the base image" \
5862 }, \
5863 { \
5864 .name = BLOCK_OPT_DATA_FILE, \
5865 .type = QEMU_OPT_STRING, \
5866 .help = "File name of an external data file" \
5867 }, \
5868 { \
5869 .name = BLOCK_OPT_DATA_FILE_RAW, \
5870 .type = QEMU_OPT_BOOL, \
5871 .help = "The external data file must stay valid " \
5872 "as a raw image" \
5873 }, \
5874 { \
5875 .name = BLOCK_OPT_LAZY_REFCOUNTS, \
5876 .type = QEMU_OPT_BOOL, \
5877 .help = "Postpone refcount updates", \
5878 .def_value_str = "off" \
5879 }, \
5880 { \
5881 .name = BLOCK_OPT_REFCOUNT_BITS, \
5882 .type = QEMU_OPT_NUMBER, \
5883 .help = "Width of a reference count entry in bits", \
5884 .def_value_str = "16" \
5885 }
5886
5887static QemuOptsList qcow2_create_opts = {
5888 .name = "qcow2-create-opts",
5889 .head = QTAILQ_HEAD_INITIALIZER(qcow2_create_opts.head),
5890 .desc = {
5891 { \
5892 .name = BLOCK_OPT_ENCRYPT, \
5893 .type = QEMU_OPT_BOOL, \
5894 .help = "Encrypt the image with format 'aes'. (Deprecated " \
5895 "in favor of " BLOCK_OPT_ENCRYPT_FORMAT "=aes)", \
5896 }, \
5897 { \
5898 .name = BLOCK_OPT_ENCRYPT_FORMAT, \
5899 .type = QEMU_OPT_STRING, \
5900 .help = "Encrypt the image, format choices: 'aes', 'luks'", \
5901 }, \
5902 BLOCK_CRYPTO_OPT_DEF_KEY_SECRET("encrypt.", \
5903 "ID of secret providing qcow AES key or LUKS passphrase"), \
5904 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG("encrypt."), \
5905 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE("encrypt."), \
5906 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG("encrypt."), \
5907 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG("encrypt."), \
5908 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG("encrypt."), \
5909 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."), \
5910 { \
5911 .name = BLOCK_OPT_CLUSTER_SIZE, \
5912 .type = QEMU_OPT_SIZE, \
5913 .help = "qcow2 cluster size", \
5914 .def_value_str = stringify(DEFAULT_CLUSTER_SIZE) \
5915 }, \
5916 { \
5917 .name = BLOCK_OPT_EXTL2, \
5918 .type = QEMU_OPT_BOOL, \
5919 .help = "Extended L2 tables", \
5920 .def_value_str = "off" \
5921 }, \
5922 { \
5923 .name = BLOCK_OPT_PREALLOC, \
5924 .type = QEMU_OPT_STRING, \
5925 .help = "Preallocation mode (allowed values: off, " \
5926 "metadata, falloc, full)" \
5927 }, \
5928 { \
5929 .name = BLOCK_OPT_COMPRESSION_TYPE, \
5930 .type = QEMU_OPT_STRING, \
5931 .help = "Compression method used for image cluster " \
5932 "compression", \
5933 .def_value_str = "zlib" \
5934 },
5935 QCOW_COMMON_OPTIONS,
5936 { }
5937 }
5938};
5939
5940static QemuOptsList qcow2_amend_opts = {
5941 .name = "qcow2-amend-opts",
5942 .head = QTAILQ_HEAD_INITIALIZER(qcow2_amend_opts.head),
5943 .desc = {
5944 BLOCK_CRYPTO_OPT_DEF_LUKS_STATE("encrypt."),
5945 BLOCK_CRYPTO_OPT_DEF_LUKS_KEYSLOT("encrypt."),
5946 BLOCK_CRYPTO_OPT_DEF_LUKS_OLD_SECRET("encrypt."),
5947 BLOCK_CRYPTO_OPT_DEF_LUKS_NEW_SECRET("encrypt."),
5948 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME("encrypt."),
5949 QCOW_COMMON_OPTIONS,
5950 { }
5951 }
5952};
5953
5954static const char *const qcow2_strong_runtime_opts[] = {
5955 "encrypt." BLOCK_CRYPTO_OPT_QCOW_KEY_SECRET,
5956
5957 NULL
5958};
5959
5960BlockDriver bdrv_qcow2 = {
5961 .format_name = "qcow2",
5962 .instance_size = sizeof(BDRVQcow2State),
5963 .bdrv_probe = qcow2_probe,
5964 .bdrv_open = qcow2_open,
5965 .bdrv_close = qcow2_close,
5966 .bdrv_reopen_prepare = qcow2_reopen_prepare,
5967 .bdrv_reopen_commit = qcow2_reopen_commit,
5968 .bdrv_reopen_commit_post = qcow2_reopen_commit_post,
5969 .bdrv_reopen_abort = qcow2_reopen_abort,
5970 .bdrv_join_options = qcow2_join_options,
5971 .bdrv_child_perm = bdrv_default_perms,
5972 .bdrv_co_create_opts = qcow2_co_create_opts,
5973 .bdrv_co_create = qcow2_co_create,
5974 .bdrv_has_zero_init = qcow2_has_zero_init,
5975 .bdrv_co_block_status = qcow2_co_block_status,
5976
5977 .bdrv_co_preadv_part = qcow2_co_preadv_part,
5978 .bdrv_co_pwritev_part = qcow2_co_pwritev_part,
5979 .bdrv_co_flush_to_os = qcow2_co_flush_to_os,
5980
5981 .bdrv_co_pwrite_zeroes = qcow2_co_pwrite_zeroes,
5982 .bdrv_co_pdiscard = qcow2_co_pdiscard,
5983 .bdrv_co_copy_range_from = qcow2_co_copy_range_from,
5984 .bdrv_co_copy_range_to = qcow2_co_copy_range_to,
5985 .bdrv_co_truncate = qcow2_co_truncate,
5986 .bdrv_co_pwritev_compressed_part = qcow2_co_pwritev_compressed_part,
5987 .bdrv_make_empty = qcow2_make_empty,
5988
5989 .bdrv_snapshot_create = qcow2_snapshot_create,
5990 .bdrv_snapshot_goto = qcow2_snapshot_goto,
5991 .bdrv_snapshot_delete = qcow2_snapshot_delete,
5992 .bdrv_snapshot_list = qcow2_snapshot_list,
5993 .bdrv_snapshot_load_tmp = qcow2_snapshot_load_tmp,
5994 .bdrv_measure = qcow2_measure,
5995 .bdrv_get_info = qcow2_get_info,
5996 .bdrv_get_specific_info = qcow2_get_specific_info,
5997
5998 .bdrv_save_vmstate = qcow2_save_vmstate,
5999 .bdrv_load_vmstate = qcow2_load_vmstate,
6000
6001 .is_format = true,
6002 .supports_backing = true,
6003 .bdrv_change_backing_file = qcow2_change_backing_file,
6004
6005 .bdrv_refresh_limits = qcow2_refresh_limits,
6006 .bdrv_co_invalidate_cache = qcow2_co_invalidate_cache,
6007 .bdrv_inactivate = qcow2_inactivate,
6008
6009 .create_opts = &qcow2_create_opts,
6010 .amend_opts = &qcow2_amend_opts,
6011 .strong_runtime_opts = qcow2_strong_runtime_opts,
6012 .mutable_opts = mutable_opts,
6013 .bdrv_co_check = qcow2_co_check,
6014 .bdrv_amend_options = qcow2_amend_options,
6015 .bdrv_co_amend = qcow2_co_amend,
6016
6017 .bdrv_detach_aio_context = qcow2_detach_aio_context,
6018 .bdrv_attach_aio_context = qcow2_attach_aio_context,
6019
6020 .bdrv_supports_persistent_dirty_bitmap =
6021 qcow2_supports_persistent_dirty_bitmap,
6022 .bdrv_co_can_store_new_dirty_bitmap = qcow2_co_can_store_new_dirty_bitmap,
6023 .bdrv_co_remove_persistent_dirty_bitmap =
6024 qcow2_co_remove_persistent_dirty_bitmap,
6025};
6026
6027static void bdrv_qcow2_init(void)
6028{
6029 bdrv_register(&bdrv_qcow2);
6030}
6031
6032block_init(bdrv_qcow2_init);
6033