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