Lines Matching +full:- +full:- +full:disable +full:- +full:coroutine +full:- +full:pool
4 * Copyright (c) 2004-2006 Fabrice Bellard
28 #include "system/block-backend.h"
29 #include "qemu/main-loop.h"
32 #include "qemu/error-report.h"
34 #include "qapi/qapi-events-block-core.h"
42 #include "qapi/qobject-input-visitor.h"
43 #include "qapi/qapi-visit-block-core.h"
46 #include "block/dirty-bitmap.h"
51 - Support for multiple incremental snapshots.
52 - Memory management by reference counts.
53 - Clusters which have a reference count of one have the bit
55 - Size of compressed clusters is stored in sectors to reduce bit usage
57 - Support for storing additional data (such as the VM state) in the
59 - If a backing store is used, the cluster size is not constrained
61 - L2 tables have always a size of one cluster.
90 be32_to_cpu(cow_header->magic) == QCOW_MAGIC && in qcow2_probe()
91 be32_to_cpu(cow_header->version) >= 2) in qcow2_probe()
104 BDRVQcow2State *s = bs->opaque; in qcow2_crypto_hdr_read_func()
107 if ((offset + buflen) > s->crypto_header.length) { in qcow2_crypto_hdr_read_func()
109 return -1; in qcow2_crypto_hdr_read_func()
112 ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buflen, buf, in qcow2_crypto_hdr_read_func()
115 error_setg_errno(errp, -ret, "Could not read encryption header"); in qcow2_crypto_hdr_read_func()
116 return -1; in qcow2_crypto_hdr_read_func()
127 BDRVQcow2State *s = bs->opaque; in qcow2_crypto_hdr_init_func()
133 error_setg_errno(errp, -ret, in qcow2_crypto_hdr_init_func()
136 return -1; in qcow2_crypto_hdr_init_func()
139 s->crypto_header.length = headerlen; in qcow2_crypto_hdr_init_func()
140 s->crypto_header.offset = ret; in qcow2_crypto_hdr_init_func()
147 clusterlen = size_to_clusters(s, headerlen) * s->cluster_size; in qcow2_crypto_hdr_init_func()
149 ret = bdrv_co_pwrite_zeroes(bs->file, ret, clusterlen, 0); in qcow2_crypto_hdr_init_func()
151 error_setg_errno(errp, -ret, "Could not zero fill encryption header"); in qcow2_crypto_hdr_init_func()
152 return -1; in qcow2_crypto_hdr_init_func()
159 /* The graph lock must be held when called in coroutine context */
166 BDRVQcow2State *s = bs->opaque; in qcow2_crypto_hdr_write_func()
169 if ((offset + buflen) > s->crypto_header.length) { in qcow2_crypto_hdr_write_func()
171 return -1; in qcow2_crypto_hdr_write_func()
174 ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buflen, buf, in qcow2_crypto_hdr_write_func()
177 error_setg_errno(errp, -ret, "Could not read encryption header"); in qcow2_crypto_hdr_write_func()
178 return -1; in qcow2_crypto_hdr_write_func()
202 * return 0 upon success, non-0 otherwise
209 BDRVQcow2State *s = bs->opaque; in qcow2_read_extensions()
227 if (offset > s->cluster_size) in qcow2_read_extensions()
233 ret = bdrv_co_pread(bs->file, offset, sizeof(ext), &ext, 0); in qcow2_read_extensions()
235 error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: " in qcow2_read_extensions()
245 if (offset > end_offset || ext.len > end_offset - offset) { in qcow2_read_extensions()
247 return -EINVAL; in qcow2_read_extensions()
255 if (ext.len >= sizeof(bs->backing_format)) { in qcow2_read_extensions()
258 sizeof(bs->backing_format)); in qcow2_read_extensions()
261 ret = bdrv_co_pread(bs->file, offset, ext.len, bs->backing_format, 0); in qcow2_read_extensions()
263 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: " in qcow2_read_extensions()
267 bs->backing_format[ext.len] = '\0'; in qcow2_read_extensions()
268 s->image_backing_format = g_strdup(bs->backing_format); in qcow2_read_extensions()
270 printf("Qcow2: Got format extension %s\n", bs->backing_format); in qcow2_read_extensions()
277 ret = bdrv_co_pread(bs->file, offset, ext.len, feature_table, 0); in qcow2_read_extensions()
279 error_setg_errno(errp, -ret, "ERROR: ext_feature_table: " in qcow2_read_extensions()
291 if (s->crypt_method_header != QCOW_CRYPT_LUKS) { in qcow2_read_extensions()
294 return -EINVAL; in qcow2_read_extensions()
300 return -EINVAL; in qcow2_read_extensions()
303 ret = bdrv_co_pread(bs->file, offset, ext.len, &s->crypto_header, 0); in qcow2_read_extensions()
305 error_setg_errno(errp, -ret, in qcow2_read_extensions()
309 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset); in qcow2_read_extensions()
310 s->crypto_header.length = be64_to_cpu(s->crypto_header.length); in qcow2_read_extensions()
312 if ((s->crypto_header.offset % s->cluster_size) != 0) { in qcow2_read_extensions()
315 s->crypto_header.offset, s->cluster_size); in qcow2_read_extensions()
316 return -EINVAL; in qcow2_read_extensions()
322 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", in qcow2_read_extensions()
325 if (!s->crypto) { in qcow2_read_extensions()
326 return -EINVAL; in qcow2_read_extensions()
332 error_setg_errno(errp, -ret, "bitmaps_ext: " in qcow2_read_extensions()
334 return -EINVAL; in qcow2_read_extensions()
337 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) { in qcow2_read_extensions()
338 if (s->qcow_version < 3) { in qcow2_read_extensions()
350 "run 'qemu-img check -r' on the image " in qcow2_read_extensions()
359 ret = bdrv_co_pread(bs->file, offset, ext.len, &bitmaps_ext, 0); in qcow2_read_extensions()
361 error_setg_errno(errp, -ret, "bitmaps_ext: " in qcow2_read_extensions()
367 error_setg_errno(errp, -ret, "bitmaps_ext: " in qcow2_read_extensions()
369 return -EINVAL; in qcow2_read_extensions()
383 return -EINVAL; in qcow2_read_extensions()
388 return -EINVAL; in qcow2_read_extensions()
394 return -EINVAL; in qcow2_read_extensions()
404 return -EINVAL; in qcow2_read_extensions()
407 s->nb_bitmaps = bitmaps_ext.nb_bitmaps; in qcow2_read_extensions()
408 s->bitmap_directory_offset = in qcow2_read_extensions()
410 s->bitmap_directory_size = in qcow2_read_extensions()
416 s->bitmap_directory_offset, s->nb_bitmaps); in qcow2_read_extensions()
422 s->image_data_file = g_malloc0(ext.len + 1); in qcow2_read_extensions()
423 ret = bdrv_co_pread(bs->file, offset, ext.len, s->image_data_file, 0); in qcow2_read_extensions()
425 error_setg_errno(errp, -ret, in qcow2_read_extensions()
430 printf("Qcow2: Got external data file %s\n", s->image_data_file); in qcow2_read_extensions()
436 /* unknown magic - save it in case we need to rewrite the header */ in qcow2_read_extensions()
443 uext->magic = ext.magic; in qcow2_read_extensions()
444 uext->len = ext.len; in qcow2_read_extensions()
445 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next); in qcow2_read_extensions()
447 ret = bdrv_co_pread(bs->file, offset, uext->len, uext->data, 0); in qcow2_read_extensions()
449 error_setg_errno(errp, -ret, "ERROR: unknown extension: " in qcow2_read_extensions()
465 BDRVQcow2State *s = bs->opaque; in cleanup_unknown_header_ext()
468 QLIST_FOREACH_SAFE(uext, &s->unknown_header_ext, next, next) { in cleanup_unknown_header_ext()
479 while (table && table->name[0] != '\0') { in report_unsupported_feature()
480 if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) { in report_unsupported_feature()
481 if (mask & (1ULL << table->bit)) { in report_unsupported_feature()
482 if (features->len > 0) { in report_unsupported_feature()
485 g_string_append_printf(features, "%.46s", table->name); in report_unsupported_feature()
486 mask &= ~(1ULL << table->bit); in report_unsupported_feature()
493 if (features->len > 0) { in report_unsupported_feature()
500 error_setg(errp, "Unsupported qcow2 feature(s): %s", features->str); in report_unsupported_feature()
512 BDRVQcow2State *s = bs->opaque; in qcow2_mark_dirty()
516 assert(s->qcow_version >= 3); in qcow2_mark_dirty()
518 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { in qcow2_mark_dirty()
522 val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY); in qcow2_mark_dirty()
523 ret = bdrv_pwrite_sync(bs->file, in qcow2_mark_dirty()
531 s->incompatible_features |= QCOW2_INCOMPAT_DIRTY; in qcow2_mark_dirty()
542 BDRVQcow2State *s = bs->opaque; in qcow2_mark_clean()
544 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { in qcow2_mark_clean()
547 s->incompatible_features &= ~QCOW2_INCOMPAT_DIRTY; in qcow2_mark_clean()
564 BDRVQcow2State *s = bs->opaque; in qcow2_mark_corrupt()
566 s->incompatible_features |= QCOW2_INCOMPAT_CORRUPT; in qcow2_mark_corrupt()
577 BDRVQcow2State *s = bs->opaque; in qcow2_mark_consistent()
579 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { in qcow2_mark_consistent()
585 s->incompatible_features &= ~QCOW2_INCOMPAT_CORRUPT; in qcow2_mark_consistent()
595 out->corruptions += src->corruptions; in qcow2_add_check_result()
596 out->leaks += src->leaks; in qcow2_add_check_result()
597 out->check_errors += src->check_errors; in qcow2_add_check_result()
598 out->corruptions_fixed += src->corruptions_fixed; in qcow2_add_check_result()
599 out->leaks_fixed += src->leaks_fixed; in qcow2_add_check_result()
602 out->image_end_offset = src->image_end_offset; in qcow2_add_check_result()
603 out->bfi = src->bfi; in qcow2_add_check_result()
636 if (fix && result->check_errors == 0 && result->corruptions == 0) { in qcow2_co_check_locked()
650 BDRVQcow2State *s = bs->opaque; in qcow2_co_check()
653 qemu_co_mutex_lock(&s->lock); in qcow2_co_check()
655 qemu_co_mutex_unlock(&s->lock); in qcow2_co_check()
664 BDRVQcow2State *s = bs->opaque; in qcow2_validate_table()
668 return -EFBIG; in qcow2_validate_table()
673 if ((INT64_MAX - entries * entry_len < offset) || in qcow2_validate_table()
676 return -EINVAL; in qcow2_validate_table()
841 BDRVQcow2State *s = bs->opaque; in cache_clean_timer_cb()
842 qcow2_cache_clean_unused(s->l2_table_cache); in cache_clean_timer_cb()
843 qcow2_cache_clean_unused(s->refcount_block_cache); in cache_clean_timer_cb()
844 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + in cache_clean_timer_cb()
845 (int64_t) s->cache_clean_interval * 1000); in cache_clean_timer_cb()
850 BDRVQcow2State *s = bs->opaque; in cache_clean_timer_init()
851 if (s->cache_clean_interval > 0) { in cache_clean_timer_init()
852 s->cache_clean_timer = in cache_clean_timer_init()
856 timer_mod(s->cache_clean_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + in cache_clean_timer_init()
857 (int64_t) s->cache_clean_interval * 1000); in cache_clean_timer_init()
863 BDRVQcow2State *s = bs->opaque; in cache_clean_timer_del()
864 if (s->cache_clean_timer) { in cache_clean_timer_del()
865 timer_free(s->cache_clean_timer); in cache_clean_timer_del()
866 s->cache_clean_timer = NULL; in cache_clean_timer_del()
886 BDRVQcow2State *s = bs->opaque; in read_cache_sizes()
890 int min_refcount_cache = MIN_REFCOUNT_CACHE_SIZE * s->cluster_size; in read_cache_sizes()
891 uint64_t virtual_disk_size = bs->total_sectors * BDRV_SECTOR_SIZE; in read_cache_sizes()
892 uint64_t max_l2_entries = DIV_ROUND_UP(virtual_disk_size, s->cluster_size); in read_cache_sizes()
896 s->cluster_size); in read_cache_sizes()
910 opts, QCOW2_OPT_L2_CACHE_ENTRY_SIZE, s->cluster_size); in read_cache_sizes()
932 *refcount_cache_size = combined_cache_size - *l2_cache_size; in read_cache_sizes()
934 *l2_cache_size = combined_cache_size - *refcount_cache_size; in read_cache_sizes()
940 *refcount_cache_size = combined_cache_size - *l2_cache_size; in read_cache_sizes()
944 *l2_cache_size = combined_cache_size - *refcount_cache_size; in read_cache_sizes()
955 *l2_cache_entry_size = MIN(s->cluster_size, 4096); in read_cache_sizes()
962 *l2_cache_entry_size > s->cluster_size || in read_cache_sizes()
966 1 << MIN_CLUSTER_BITS, s->cluster_size); in read_cache_sizes()
989 BDRVQcow2State *s = bs->opaque; in qcow2_update_options_prepare()
1004 ret = -EINVAL; in qcow2_update_options_prepare()
1011 ret = -EINVAL; in qcow2_update_options_prepare()
1021 ret = -EINVAL; in qcow2_update_options_prepare()
1025 refcount_cache_size /= s->cluster_size; in qcow2_update_options_prepare()
1031 ret = -EINVAL; in qcow2_update_options_prepare()
1036 if (s->l2_table_cache) { in qcow2_update_options_prepare()
1037 ret = qcow2_cache_flush(bs, s->l2_table_cache); in qcow2_update_options_prepare()
1039 error_setg_errno(errp, -ret, "Failed to flush the L2 table cache"); in qcow2_update_options_prepare()
1044 if (s->refcount_block_cache) { in qcow2_update_options_prepare()
1045 ret = qcow2_cache_flush(bs, s->refcount_block_cache); in qcow2_update_options_prepare()
1047 error_setg_errno(errp, -ret, in qcow2_update_options_prepare()
1053 r->l2_slice_size = l2_cache_entry_size / l2_entry_size(s); in qcow2_update_options_prepare()
1054 r->l2_table_cache = qcow2_cache_create(bs, l2_cache_size, in qcow2_update_options_prepare()
1056 r->refcount_block_cache = qcow2_cache_create(bs, refcount_cache_size, in qcow2_update_options_prepare()
1057 s->cluster_size); in qcow2_update_options_prepare()
1058 if (r->l2_table_cache == NULL || r->refcount_block_cache == NULL) { in qcow2_update_options_prepare()
1060 ret = -ENOMEM; in qcow2_update_options_prepare()
1065 r->cache_clean_interval = in qcow2_update_options_prepare()
1069 if (r->cache_clean_interval != 0) { in qcow2_update_options_prepare()
1072 ret = -EINVAL; in qcow2_update_options_prepare()
1076 if (r->cache_clean_interval > UINT_MAX) { in qcow2_update_options_prepare()
1078 ret = -EINVAL; in qcow2_update_options_prepare()
1082 /* lazy-refcounts; flush if going from enabled to disabled */ in qcow2_update_options_prepare()
1083 r->use_lazy_refcounts = qemu_opt_get_bool(opts, QCOW2_OPT_LAZY_REFCOUNTS, in qcow2_update_options_prepare()
1084 (s->compatible_features & QCOW2_COMPAT_LAZY_REFCOUNTS)); in qcow2_update_options_prepare()
1085 if (r->use_lazy_refcounts && s->qcow_version < 3) { in qcow2_update_options_prepare()
1088 ret = -EINVAL; in qcow2_update_options_prepare()
1092 if (s->use_lazy_refcounts && !r->use_lazy_refcounts) { in qcow2_update_options_prepare()
1095 error_setg_errno(errp, -ret, "Failed to disable lazy refcounts"); in qcow2_update_options_prepare()
1109 ret = -EINVAL; in qcow2_update_options_prepare()
1126 "'overlap-check'. Allowed are any of the following: " in qcow2_update_options_prepare()
1128 ret = -EINVAL; in qcow2_update_options_prepare()
1132 r->overlap_check = 0; in qcow2_update_options_prepare()
1134 /* overlap-check defines a template bitmask, but every flag may be in qcow2_update_options_prepare()
1136 r->overlap_check |= in qcow2_update_options_prepare()
1141 r->discard_passthrough[QCOW2_DISCARD_NEVER] = false; in qcow2_update_options_prepare()
1142 r->discard_passthrough[QCOW2_DISCARD_ALWAYS] = true; in qcow2_update_options_prepare()
1143 r->discard_passthrough[QCOW2_DISCARD_REQUEST] = in qcow2_update_options_prepare()
1146 r->discard_passthrough[QCOW2_DISCARD_SNAPSHOT] = in qcow2_update_options_prepare()
1148 r->discard_passthrough[QCOW2_DISCARD_OTHER] = in qcow2_update_options_prepare()
1151 r->discard_no_unref = qemu_opt_get_bool(opts, QCOW2_OPT_DISCARD_NO_UNREF, in qcow2_update_options_prepare()
1153 if (r->discard_no_unref && s->qcow_version < 3) { in qcow2_update_options_prepare()
1155 "discard-no-unref is only supported since qcow2 version 3"); in qcow2_update_options_prepare()
1156 ret = -EINVAL; in qcow2_update_options_prepare()
1160 switch (s->crypt_method_header) { in qcow2_update_options_prepare()
1165 ret = -EINVAL; in qcow2_update_options_prepare()
1175 ret = -EINVAL; in qcow2_update_options_prepare()
1179 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp); in qcow2_update_options_prepare()
1180 if (!r->crypto_opts) { in qcow2_update_options_prepare()
1181 ret = -EINVAL; in qcow2_update_options_prepare()
1191 ret = -EINVAL; in qcow2_update_options_prepare()
1195 r->crypto_opts = block_crypto_open_opts_init(encryptopts, errp); in qcow2_update_options_prepare()
1196 if (!r->crypto_opts) { in qcow2_update_options_prepare()
1197 ret = -EINVAL; in qcow2_update_options_prepare()
1204 s->crypt_method_header); in qcow2_update_options_prepare()
1205 ret = -EINVAL; in qcow2_update_options_prepare()
1220 BDRVQcow2State *s = bs->opaque; in qcow2_update_options_commit()
1223 if (s->l2_table_cache) { in qcow2_update_options_commit()
1224 qcow2_cache_destroy(s->l2_table_cache); in qcow2_update_options_commit()
1226 if (s->refcount_block_cache) { in qcow2_update_options_commit()
1227 qcow2_cache_destroy(s->refcount_block_cache); in qcow2_update_options_commit()
1229 s->l2_table_cache = r->l2_table_cache; in qcow2_update_options_commit()
1230 s->refcount_block_cache = r->refcount_block_cache; in qcow2_update_options_commit()
1231 s->l2_slice_size = r->l2_slice_size; in qcow2_update_options_commit()
1233 s->overlap_check = r->overlap_check; in qcow2_update_options_commit()
1234 s->use_lazy_refcounts = r->use_lazy_refcounts; in qcow2_update_options_commit()
1237 s->discard_passthrough[i] = r->discard_passthrough[i]; in qcow2_update_options_commit()
1240 s->discard_no_unref = r->discard_no_unref; in qcow2_update_options_commit()
1242 if (s->cache_clean_interval != r->cache_clean_interval) { in qcow2_update_options_commit()
1244 s->cache_clean_interval = r->cache_clean_interval; in qcow2_update_options_commit()
1248 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); in qcow2_update_options_commit()
1249 s->crypto_opts = r->crypto_opts; in qcow2_update_options_commit()
1255 if (r->l2_table_cache) { in qcow2_update_options_abort()
1256 qcow2_cache_destroy(r->l2_table_cache); in qcow2_update_options_abort()
1258 if (r->refcount_block_cache) { in qcow2_update_options_abort()
1259 qcow2_cache_destroy(r->refcount_block_cache); in qcow2_update_options_abort()
1261 qapi_free_QCryptoBlockOpenOptions(r->crypto_opts); in qcow2_update_options_abort()
1283 switch (s->compression_type) { in validate_compression_type()
1292 s->compression_type); in validate_compression_type()
1293 return -ENOTSUP; in validate_compression_type()
1300 if (s->compression_type == QCOW2_COMPRESSION_TYPE_ZLIB) { in validate_compression_type()
1301 if (s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION) { in validate_compression_type()
1304 return -EINVAL; in validate_compression_type()
1307 if (!(s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION)) { in validate_compression_type()
1310 return -EINVAL; in validate_compression_type()
1317 /* Called with s->lock held. */
1323 BDRVQcow2State *s = bs->opaque; in qcow2_do_open()
1331 ret = bdrv_co_pread(bs->file, 0, sizeof(header), &header, 0); in qcow2_do_open()
1333 error_setg_errno(errp, -ret, "Could not read qcow2 header"); in qcow2_do_open()
1353 ret = -EINVAL; in qcow2_do_open()
1358 ret = -ENOTSUP; in qcow2_do_open()
1362 s->qcow_version = header.version; in qcow2_do_open()
1369 ret = -EINVAL; in qcow2_do_open()
1373 s->cluster_bits = header.cluster_bits; in qcow2_do_open()
1374 s->cluster_size = 1 << s->cluster_bits; in qcow2_do_open()
1393 ret = -EINVAL; in qcow2_do_open()
1398 if (header.header_length > s->cluster_size) { in qcow2_do_open()
1400 ret = -EINVAL; in qcow2_do_open()
1405 s->unknown_header_fields_size = header.header_length - sizeof(header); in qcow2_do_open()
1406 s->unknown_header_fields = g_malloc(s->unknown_header_fields_size); in qcow2_do_open()
1407 ret = bdrv_co_pread(bs->file, sizeof(header), in qcow2_do_open()
1408 s->unknown_header_fields_size, in qcow2_do_open()
1409 s->unknown_header_fields, 0); in qcow2_do_open()
1411 error_setg_errno(errp, -ret, "Could not read unknown qcow2 header " in qcow2_do_open()
1417 if (header.backing_file_offset > s->cluster_size) { in qcow2_do_open()
1419 ret = -EINVAL; in qcow2_do_open()
1430 s->incompatible_features = header.incompatible_features; in qcow2_do_open()
1431 s->compatible_features = header.compatible_features; in qcow2_do_open()
1432 s->autoclear_features = header.autoclear_features; in qcow2_do_open()
1441 s->compression_type = header.compression_type; in qcow2_do_open()
1443 s->compression_type = QCOW2_COMPRESSION_TYPE_ZLIB; in qcow2_do_open()
1451 if (s->incompatible_features & ~QCOW2_INCOMPAT_MASK) { in qcow2_do_open()
1456 s->incompatible_features & in qcow2_do_open()
1458 ret = -ENOTSUP; in qcow2_do_open()
1463 if (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT) { in qcow2_do_open()
1469 ret = -EACCES; in qcow2_do_open()
1474 s->subclusters_per_cluster = in qcow2_do_open()
1476 s->subcluster_size = s->cluster_size / s->subclusters_per_cluster; in qcow2_do_open()
1477 s->subcluster_bits = ctz32(s->subcluster_size); in qcow2_do_open()
1479 if (s->subcluster_size < (1 << MIN_CLUSTER_BITS)) { in qcow2_do_open()
1480 error_setg(errp, "Unsupported subcluster size: %d", s->subcluster_size); in qcow2_do_open()
1481 ret = -EINVAL; in qcow2_do_open()
1489 ret = -EINVAL; in qcow2_do_open()
1492 s->refcount_order = header.refcount_order; in qcow2_do_open()
1493 s->refcount_bits = 1 << s->refcount_order; in qcow2_do_open()
1494 s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1); in qcow2_do_open()
1495 s->refcount_max += s->refcount_max - 1; in qcow2_do_open()
1497 s->crypt_method_header = header.crypt_method; in qcow2_do_open()
1498 if (s->crypt_method_header) { in qcow2_do_open()
1500 s->crypt_method_header == QCOW_CRYPT_AES) { in qcow2_do_open()
1502 "Use of AES-CBC encrypted qcow2 images is no longer " in qcow2_do_open()
1505 "You can use 'qemu-img convert' to convert your " in qcow2_do_open()
1509 ret = -ENOSYS; in qcow2_do_open()
1513 if (s->crypt_method_header == QCOW_CRYPT_AES) { in qcow2_do_open()
1514 s->crypt_physical_offset = false; in qcow2_do_open()
1519 s->crypt_physical_offset = true; in qcow2_do_open()
1522 bs->encrypted = true; in qcow2_do_open()
1525 s->l2_bits = s->cluster_bits - ctz32(l2_entry_size(s)); in qcow2_do_open()
1526 s->l2_size = 1 << s->l2_bits; in qcow2_do_open()
1527 /* 2^(s->refcount_order - 3) is the refcount width in bytes */ in qcow2_do_open()
1528 s->refcount_block_bits = s->cluster_bits - (s->refcount_order - 3); in qcow2_do_open()
1529 s->refcount_block_size = 1 << s->refcount_block_bits; in qcow2_do_open()
1530 bs->total_sectors = header.size / BDRV_SECTOR_SIZE; in qcow2_do_open()
1531 s->csize_shift = (62 - (s->cluster_bits - 8)); in qcow2_do_open()
1532 s->csize_mask = (1 << (s->cluster_bits - 8)) - 1; in qcow2_do_open()
1533 s->cluster_offset_mask = (1LL << s->csize_shift) - 1; in qcow2_do_open()
1535 s->refcount_table_offset = header.refcount_table_offset; in qcow2_do_open()
1536 s->refcount_table_size = in qcow2_do_open()
1537 header.refcount_table_clusters << (s->cluster_bits - 3); in qcow2_do_open()
1541 ret = -EINVAL; in qcow2_do_open()
1545 ret = qcow2_validate_table(bs, s->refcount_table_offset, in qcow2_do_open()
1547 s->cluster_size, QCOW_MAX_REFTABLE_SIZE, in qcow2_do_open()
1578 s->l1_size = header.l1_size; in qcow2_do_open()
1579 s->l1_table_offset = header.l1_table_offset; in qcow2_do_open()
1584 ret = -EFBIG; in qcow2_do_open()
1587 s->l1_vm_state_index = l1_vm_state_index; in qcow2_do_open()
1591 if (s->l1_size < s->l1_vm_state_index) { in qcow2_do_open()
1593 ret = -EINVAL; in qcow2_do_open()
1597 if (s->l1_size > 0) { in qcow2_do_open()
1598 s->l1_table = qemu_try_blockalign(bs->file->bs, s->l1_size * L1E_SIZE); in qcow2_do_open()
1599 if (s->l1_table == NULL) { in qcow2_do_open()
1601 ret = -ENOMEM; in qcow2_do_open()
1604 ret = bdrv_co_pread(bs->file, s->l1_table_offset, s->l1_size * L1E_SIZE, in qcow2_do_open()
1605 s->l1_table, 0); in qcow2_do_open()
1607 error_setg_errno(errp, -ret, "Could not read L1 table"); in qcow2_do_open()
1610 for(i = 0;i < s->l1_size; i++) { in qcow2_do_open()
1611 s->l1_table[i] = be64_to_cpu(s->l1_table[i]); in qcow2_do_open()
1615 /* Parse driver-specific options */ in qcow2_do_open()
1621 s->flags = flags; in qcow2_do_open()
1625 error_setg_errno(errp, -ret, "Could not initialize refcount handling"); in qcow2_do_open()
1629 QLIST_INIT(&s->cluster_allocs); in qcow2_do_open()
1630 QTAILQ_INIT(&s->discards); in qcow2_do_open()
1635 ret = -EINVAL; in qcow2_do_open()
1641 * Don't open the data file for 'qemu-img info' so that it can be used in qcow2_do_open()
1647 if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) { in qcow2_do_open()
1648 s->data_file = NULL; in qcow2_do_open()
1650 s->data_file = bs->file; in qcow2_do_open()
1652 qdict_extract_subqdict(options, NULL, "data-file."); in qcow2_do_open()
1653 qdict_del(options, "data-file"); in qcow2_do_open()
1657 s->data_file = bdrv_co_open_child(NULL, options, "data-file", bs, in qcow2_do_open()
1662 ret = -EINVAL; in qcow2_do_open()
1666 if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) { in qcow2_do_open()
1667 if (!s->data_file && s->image_data_file) { in qcow2_do_open()
1669 s->data_file = bdrv_co_open_child(s->image_data_file, options, in qcow2_do_open()
1670 "data-file", bs, in qcow2_do_open()
1674 if (!s->data_file) { in qcow2_do_open()
1675 ret = -EINVAL; in qcow2_do_open()
1679 if (!s->data_file) { in qcow2_do_open()
1680 error_setg(errp, "'data-file' is required for this image"); in qcow2_do_open()
1681 ret = -EINVAL; in qcow2_do_open()
1686 bs->file->role &= ~BDRV_CHILD_DATA; in qcow2_do_open()
1689 bdrv_child_refresh_perms(bs, bs->file, &error_abort); in qcow2_do_open()
1691 if (s->data_file) { in qcow2_do_open()
1692 error_setg(errp, "'data-file' can only be set for images with " in qcow2_do_open()
1694 ret = -EINVAL; in qcow2_do_open()
1698 s->data_file = bs->file; in qcow2_do_open()
1701 error_setg(errp, "data-file-raw requires a data file"); in qcow2_do_open()
1702 ret = -EINVAL; in qcow2_do_open()
1712 if (s->crypt_method_header && !s->crypto) { in qcow2_do_open()
1713 if (s->crypt_method_header == QCOW_CRYPT_AES) { in qcow2_do_open()
1718 s->crypto = qcrypto_block_open(s->crypto_opts, "encrypt.", in qcow2_do_open()
1720 if (!s->crypto) { in qcow2_do_open()
1721 ret = -EINVAL; in qcow2_do_open()
1726 s->crypt_method_header); in qcow2_do_open()
1727 ret = -EINVAL; in qcow2_do_open()
1735 if (len > MIN(1023, s->cluster_size - header.backing_file_offset) || in qcow2_do_open()
1736 len >= sizeof(bs->backing_file)) { in qcow2_do_open()
1738 ret = -EINVAL; in qcow2_do_open()
1742 s->image_backing_file = g_malloc(len + 1); in qcow2_do_open()
1743 ret = bdrv_co_pread(bs->file, header.backing_file_offset, len, in qcow2_do_open()
1744 s->image_backing_file, 0); in qcow2_do_open()
1746 error_setg_errno(errp, -ret, "Could not read backing file name"); in qcow2_do_open()
1749 s->image_backing_file[len] = '\0'; in qcow2_do_open()
1756 if (!g_str_equal(s->image_backing_file, bs->backing_file)) { in qcow2_do_open()
1757 pstrcpy(bs->backing_file, sizeof(bs->backing_file), in qcow2_do_open()
1758 s->image_backing_file); in qcow2_do_open()
1759 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), in qcow2_do_open()
1760 s->image_backing_file); in qcow2_do_open()
1770 s->snapshots_offset = header.snapshots_offset; in qcow2_do_open()
1771 s->nb_snapshots = header.nb_snapshots; in qcow2_do_open()
1780 update_header |= s->autoclear_features & ~QCOW2_AUTOCLEAR_MASK; in qcow2_do_open()
1783 s->autoclear_features &= QCOW2_AUTOCLEAR_MASK; in qcow2_do_open()
1793 * 2. Invalidation of the target vm after pre-copy phase of migration, if in qcow2_do_open()
1795 * 'dirty-bitmaps' capability is disabled. in qcow2_do_open()
1804 * B. Not stored: not-persistent bitmaps and bitmaps, migrated through in qcow2_do_open()
1805 * the migration channel (with dirty-bitmaps capability). in qcow2_do_open()
1807 * On the other hand, there are two possible sub-cases: in qcow2_do_open()
1810 * case all in-RAM dirty bitmaps (both persistent and not) are in qcow2_do_open()
1832 * to disk ('dirty-bitmaps' capability disabled), or not saved in qcow2_do_open()
1833 * ('dirty-bitmaps' capability enabled), but we don't need to care in qcow2_do_open()
1848 ret = -EINVAL; in qcow2_do_open()
1858 error_setg_errno(errp, -ret, "Could not update qcow2 header"); in qcow2_do_open()
1863 bs->supported_zero_flags = header.version >= 3 ? in qcow2_do_open()
1865 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; in qcow2_do_open()
1869 (s->incompatible_features & QCOW2_INCOMPAT_DIRTY)) { in qcow2_do_open()
1876 ret = -EIO; in qcow2_do_open()
1878 error_setg_errno(errp, -ret, "Could not repair dirty image"); in qcow2_do_open()
1890 qemu_co_queue_init(&s->thread_task_queue); in qcow2_do_open()
1895 g_free(s->image_data_file); in qcow2_do_open()
1899 bdrv_co_unref_child(bs, s->data_file); in qcow2_do_open()
1902 s->data_file = NULL; in qcow2_do_open()
1904 g_free(s->unknown_header_fields); in qcow2_do_open()
1908 qemu_vfree(s->l1_table); in qcow2_do_open()
1909 /* else pre-write overlap checks in cache_destroy may crash */ in qcow2_do_open()
1910 s->l1_table = NULL; in qcow2_do_open()
1912 if (s->l2_table_cache) { in qcow2_do_open()
1913 qcow2_cache_destroy(s->l2_table_cache); in qcow2_do_open()
1915 if (s->refcount_block_cache) { in qcow2_do_open()
1916 qcow2_cache_destroy(s->refcount_block_cache); in qcow2_do_open()
1918 qcrypto_block_free(s->crypto); in qcow2_do_open()
1919 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); in qcow2_do_open()
1934 BDRVQcow2State *s = qoc->bs->opaque; in qcow2_open_entry()
1938 qemu_co_mutex_lock(&s->lock); in qcow2_open_entry()
1939 qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, true, in qcow2_open_entry()
1940 qoc->errp); in qcow2_open_entry()
1941 qemu_co_mutex_unlock(&s->lock); in qcow2_open_entry()
1949 BDRVQcow2State *s = bs->opaque; in qcow2_open()
1955 .ret = -EINPROGRESS in qcow2_open()
1965 qemu_co_mutex_init(&s->lock); in qcow2_open()
1972 AIO_WAIT_WHILE_UNLOCKED(NULL, qoc.ret == -EINPROGRESS); in qcow2_open()
1979 BDRVQcow2State *s = bs->opaque; in qcow2_refresh_limits()
1981 if (s->crypto) { in qcow2_refresh_limits()
1983 bs->bl.request_alignment = qcrypto_block_get_sector_size(s->crypto); in qcow2_refresh_limits()
1985 bs->bl.pwrite_zeroes_alignment = s->subcluster_size; in qcow2_refresh_limits()
1986 bs->bl.pdiscard_alignment = s->cluster_size; in qcow2_refresh_limits()
1993 BDRVQcow2State *s = state->bs->opaque; in qcow2_reopen_prepare()
2001 state->opaque = r; in qcow2_reopen_prepare()
2003 ret = qcow2_update_options_prepare(state->bs, r, state->options, in qcow2_reopen_prepare()
2004 state->flags, errp); in qcow2_reopen_prepare()
2009 /* We need to write out any unwritten data if we reopen read-only. */ in qcow2_reopen_prepare()
2010 if ((state->flags & BDRV_O_RDWR) == 0) { in qcow2_reopen_prepare()
2011 ret = qcow2_reopen_bitmaps_ro(state->bs, errp); in qcow2_reopen_prepare()
2016 ret = bdrv_flush(state->bs); in qcow2_reopen_prepare()
2021 ret = qcow2_mark_clean(state->bs); in qcow2_reopen_prepare()
2028 * Without an external data file, s->data_file points to the same BdrvChild in qcow2_reopen_prepare()
2029 * as bs->file. It needs to be resynced after reopen because bs->file may in qcow2_reopen_prepare()
2032 if (!has_data_file(state->bs)) { in qcow2_reopen_prepare()
2033 assert(s->data_file == state->bs->file); in qcow2_reopen_prepare()
2034 s->data_file = NULL; in qcow2_reopen_prepare()
2040 qcow2_update_options_abort(state->bs, r); in qcow2_reopen_prepare()
2047 BDRVQcow2State *s = state->bs->opaque; in qcow2_reopen_commit()
2051 qcow2_update_options_commit(state->bs, state->opaque); in qcow2_reopen_commit()
2052 if (!s->data_file) { in qcow2_reopen_commit()
2054 * If we don't have an external data file, s->data_file was cleared by in qcow2_reopen_commit()
2057 s->data_file = state->bs->file; in qcow2_reopen_commit()
2059 g_free(state->opaque); in qcow2_reopen_commit()
2066 if (state->flags & BDRV_O_RDWR) { in qcow2_reopen_commit_post()
2069 if (qcow2_reopen_bitmaps_rw(state->bs, &local_err) < 0) { in qcow2_reopen_commit_post()
2071 * This is not fatal, bitmaps just left read-only, so all following in qcow2_reopen_commit_post()
2072 * writes will fail. User can remove read-only bitmaps to unblock in qcow2_reopen_commit_post()
2077 bdrv_get_node_name(state->bs)); in qcow2_reopen_commit_post()
2084 BDRVQcow2State *s = state->bs->opaque; in qcow2_reopen_abort()
2088 if (!s->data_file) { in qcow2_reopen_abort()
2090 * If we don't have an external data file, s->data_file was cleared by in qcow2_reopen_abort()
2093 s->data_file = state->bs->file; in qcow2_reopen_abort()
2095 qcow2_update_options_abort(state->bs, state->opaque); in qcow2_reopen_abort()
2096 g_free(state->opaque); in qcow2_reopen_abort()
2150 BDRVQcow2State *s = bs->opaque; in qcow2_co_block_status()
2156 qemu_co_mutex_lock(&s->lock); in qcow2_co_block_status()
2158 if (!s->metadata_preallocation_checked) { in qcow2_co_block_status()
2160 s->metadata_preallocation = (ret == 1); in qcow2_co_block_status()
2161 s->metadata_preallocation_checked = true; in qcow2_co_block_status()
2166 qemu_co_mutex_unlock(&s->lock); in qcow2_co_block_status()
2175 type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC) && !s->crypto) { in qcow2_co_block_status()
2177 *file = s->data_file->bs; in qcow2_co_block_status()
2187 if (s->metadata_preallocation && (status & BDRV_BLOCK_DATA) && in qcow2_co_block_status()
2219 qemu_co_queue_restart_all(&l2meta->dependent_requests); in qcow2_handle_l2meta()
2221 next = l2meta->next; in qcow2_handle_l2meta()
2239 BDRVQcow2State *s = bs->opaque; in qcow2_co_preadv_encrypted()
2242 assert(bs->encrypted && s->crypto); in qcow2_co_preadv_encrypted()
2243 assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); in qcow2_co_preadv_encrypted()
2253 buf = qemu_try_blockalign(s->data_file->bs, bytes); in qcow2_co_preadv_encrypted()
2255 return -ENOMEM; in qcow2_co_preadv_encrypted()
2258 BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO); in qcow2_co_preadv_encrypted()
2259 ret = bdrv_co_pread(s->data_file, host_offset, bytes, buf, 0); in qcow2_co_preadv_encrypted()
2266 ret = -EIO; in qcow2_co_preadv_encrypted()
2292 AioTaskPool *pool, in qcow2_add_task() argument
2303 Qcow2AioTask *task = pool ? g_new(Qcow2AioTask, 1) : &local_task; in qcow2_add_task()
2317 trace_qcow2_add_task(qemu_coroutine_self(), bs, pool, in qcow2_add_task()
2322 if (!pool) { in qcow2_add_task()
2323 return func(&task->task); in qcow2_add_task()
2326 aio_task_pool_start_task(pool, &task->task); in qcow2_add_task()
2336 BDRVQcow2State *s = bs->opaque; in qcow2_co_preadv_task()
2346 assert(bs->backing); /* otherwise handled in qcow2_co_preadv_part */ in qcow2_co_preadv_task()
2348 BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_BACKING_AIO); in qcow2_co_preadv_task()
2349 return bdrv_co_preadv_part(bs->backing, offset, bytes, in qcow2_co_preadv_task()
2357 if (bs->encrypted) { in qcow2_co_preadv_task()
2362 BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO); in qcow2_co_preadv_task()
2363 return bdrv_co_preadv_part(s->data_file, host_offset, in qcow2_co_preadv_task()
2375 * the graph lock and keeps it until this coroutine has terminated.
2381 assert(!t->l2meta); in qcow2_co_preadv_task_entry()
2383 return qcow2_co_preadv_task(t->bs, t->subcluster_type, in qcow2_co_preadv_task_entry()
2384 t->host_offset, t->offset, t->bytes, in qcow2_co_preadv_task_entry()
2385 t->qiov, t->qiov_offset); in qcow2_co_preadv_task_entry()
2393 BDRVQcow2State *s = bs->opaque; in qcow2_co_preadv_part()
2403 if (s->crypto) { in qcow2_co_preadv_part()
2405 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); in qcow2_co_preadv_part()
2408 qemu_co_mutex_lock(&s->lock); in qcow2_co_preadv_part()
2411 qemu_co_mutex_unlock(&s->lock); in qcow2_co_preadv_part()
2418 (type == QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN && !bs->backing) || in qcow2_co_preadv_part()
2419 (type == QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC && !bs->backing)) in qcow2_co_preadv_part()
2434 bytes -= cur_bytes; in qcow2_co_preadv_part()
2459 for (m = l2meta; m != NULL; m = m->next) { in merge_cow()
2461 if (m->cow_start.nb_bytes == 0 && m->cow_end.nb_bytes == 0) { in merge_cow()
2466 if (m->skip_cow) { in merge_cow()
2478 if (l2meta_cow_start(m) + m->cow_start.nb_bytes != offset) { in merge_cow()
2481 assert(m->cow_start.nb_bytes == 0); in merge_cow()
2487 if (m->offset + m->cow_end.offset != offset + bytes) { in merge_cow()
2488 assert(offset + bytes > m->offset + m->cow_end.offset); in merge_cow()
2489 assert(m->cow_end.nb_bytes == 0); in merge_cow()
2495 if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) { in merge_cow()
2499 m->data_qiov = qiov; in merge_cow()
2500 m->data_qiov_offset = qiov_offset; in merge_cow()
2509 * Note that returning 0 does not guarantee non-zero data.
2520 int ret = bdrv_co_is_zero_fast(bs, m->offset + m->cow_start.offset, in is_zero_cow()
2521 m->cow_start.nb_bytes); in is_zero_cow()
2526 return bdrv_co_is_zero_fast(bs, m->offset + m->cow_end.offset, in is_zero_cow()
2527 m->cow_end.nb_bytes); in is_zero_cow()
2533 BDRVQcow2State *s = bs->opaque; in handle_alloc_space()
2536 if (!(s->data_file->bs->supported_zero_flags & BDRV_REQ_NO_FALLBACK)) { in handle_alloc_space()
2540 if (bs->encrypted) { in handle_alloc_space()
2544 for (m = l2meta; m != NULL; m = m->next) { in handle_alloc_space()
2546 uint64_t start_offset = m->alloc_offset + m->cow_start.offset; in handle_alloc_space()
2547 unsigned nb_bytes = m->cow_end.offset + m->cow_end.nb_bytes - in handle_alloc_space()
2548 m->cow_start.offset; in handle_alloc_space()
2550 if (!m->cow_start.nb_bytes && !m->cow_end.nb_bytes) { in handle_alloc_space()
2572 BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE); in handle_alloc_space()
2573 ret = bdrv_co_pwrite_zeroes(s->data_file, start_offset, nb_bytes, in handle_alloc_space()
2576 if (ret != -ENOTSUP && ret != -EAGAIN) { in handle_alloc_space()
2582 trace_qcow2_skip_cow(qemu_coroutine_self(), m->offset, m->nb_clusters); in handle_alloc_space()
2583 m->skip_cow = true; in handle_alloc_space()
2590 * Called with s->lock unlocked
2591 * l2meta - if not NULL, qcow2_co_pwritev_task() will consume it. Caller must
2600 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwritev_task()
2604 if (bs->encrypted) { in qcow2_co_pwritev_task()
2605 assert(s->crypto); in qcow2_co_pwritev_task()
2606 assert(bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); in qcow2_co_pwritev_task()
2607 crypt_buf = qemu_try_blockalign(bs->file->bs, bytes); in qcow2_co_pwritev_task()
2609 ret = -ENOMEM; in qcow2_co_pwritev_task()
2615 ret = -EIO; in qcow2_co_pwritev_task()
2637 BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO); in qcow2_co_pwritev_task()
2639 ret = bdrv_co_pwritev_part(s->data_file, host_offset, in qcow2_co_pwritev_task()
2646 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwritev_task()
2652 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwritev_task()
2656 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwritev_task()
2665 * the graph lock and keeps it until this coroutine has terminated.
2671 assert(!t->subcluster_type); in qcow2_co_pwritev_task_entry()
2673 return qcow2_co_pwritev_task(t->bs, t->host_offset, in qcow2_co_pwritev_task_entry()
2674 t->offset, t->bytes, t->qiov, t->qiov_offset, in qcow2_co_pwritev_task_entry()
2675 t->l2meta); in qcow2_co_pwritev_task_entry()
2683 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwritev_part()
2700 if (bs->encrypted) { in qcow2_co_pwritev_part()
2702 QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size in qcow2_co_pwritev_part()
2703 - offset_in_cluster); in qcow2_co_pwritev_part()
2706 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwritev_part()
2720 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwritev_part()
2733 bytes -= cur_bytes; in qcow2_co_pwritev_part()
2740 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwritev_part()
2745 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwritev_part()
2763 BDRVQcow2State *s = bs->opaque; in qcow2_inactivate()
2769 result = -EINVAL; in qcow2_inactivate()
2775 ret = qcow2_cache_flush(bs, s->l2_table_cache); in qcow2_inactivate()
2779 strerror(-ret)); in qcow2_inactivate()
2782 ret = qcow2_cache_flush(bs, s->refcount_block_cache); in qcow2_inactivate()
2786 strerror(-ret)); in qcow2_inactivate()
2799 BDRVQcow2State *s = bs->opaque; in qcow2_do_close()
2800 qemu_vfree(s->l1_table); in qcow2_do_close()
2801 /* else pre-write overlap checks in cache_destroy may crash */ in qcow2_do_close()
2802 s->l1_table = NULL; in qcow2_do_close()
2804 if (!(s->flags & BDRV_O_INACTIVE)) { in qcow2_do_close()
2809 qcow2_cache_destroy(s->l2_table_cache); in qcow2_do_close()
2810 qcow2_cache_destroy(s->refcount_block_cache); in qcow2_do_close()
2812 qcrypto_block_free(s->crypto); in qcow2_do_close()
2813 s->crypto = NULL; in qcow2_do_close()
2814 qapi_free_QCryptoBlockOpenOptions(s->crypto_opts); in qcow2_do_close()
2816 g_free(s->unknown_header_fields); in qcow2_do_close()
2819 g_free(s->image_data_file); in qcow2_do_close()
2820 g_free(s->image_backing_file); in qcow2_do_close()
2821 g_free(s->image_backing_format); in qcow2_do_close()
2828 bdrv_unref_child(bs, s->data_file); in qcow2_do_close()
2831 s->data_file = NULL; in qcow2_do_close()
2851 BDRVQcow2State *s = bs->opaque; in qcow2_co_invalidate_cache()
2853 int flags = s->flags; in qcow2_co_invalidate_cache()
2859 * Backing files are read-only which makes all of their metadata immutable, in qcow2_co_invalidate_cache()
2863 crypto = s->crypto; in qcow2_co_invalidate_cache()
2864 s->crypto = NULL; in qcow2_co_invalidate_cache()
2867 * Do not reopen s->data_file (i.e., have qcow2_do_close() not close it, in qcow2_co_invalidate_cache()
2869 * runs in the I/O path and as such we must not invoke global-state in qcow2_co_invalidate_cache()
2875 data_file = s->data_file; in qcow2_co_invalidate_cache()
2877 s->data_file = data_file; in qcow2_co_invalidate_cache()
2879 options = qdict_clone_shallow(bs->options); in qcow2_co_invalidate_cache()
2882 qemu_co_mutex_lock(&s->lock); in qcow2_co_invalidate_cache()
2884 qemu_co_mutex_unlock(&s->lock); in qcow2_co_invalidate_cache()
2888 bs->drv = NULL; in qcow2_co_invalidate_cache()
2892 s->crypto = crypto; in qcow2_co_invalidate_cache()
2902 return -ENOSPC; in header_ext_add()
2923 * Returns 0 on success, -errno in error cases.
2927 BDRVQcow2State *s = bs->opaque; in qcow2_update_header()
2930 size_t buflen = s->cluster_size; in qcow2_update_header()
2943 ret = -ENOSPC; in qcow2_update_header()
2947 header_length = sizeof(*header) + s->unknown_header_fields_size; in qcow2_update_header()
2948 total_size = bs->total_sectors * BDRV_SECTOR_SIZE; in qcow2_update_header()
2949 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3); in qcow2_update_header()
2959 .version = cpu_to_be32(s->qcow_version), in qcow2_update_header()
2962 .cluster_bits = cpu_to_be32(s->cluster_bits), in qcow2_update_header()
2964 .crypt_method = cpu_to_be32(s->crypt_method_header), in qcow2_update_header()
2965 .l1_size = cpu_to_be32(s->l1_size), in qcow2_update_header()
2966 .l1_table_offset = cpu_to_be64(s->l1_table_offset), in qcow2_update_header()
2967 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset), in qcow2_update_header()
2969 .nb_snapshots = cpu_to_be32(s->nb_snapshots), in qcow2_update_header()
2970 .snapshots_offset = cpu_to_be64(s->snapshots_offset), in qcow2_update_header()
2973 .incompatible_features = cpu_to_be64(s->incompatible_features), in qcow2_update_header()
2974 .compatible_features = cpu_to_be64(s->compatible_features), in qcow2_update_header()
2975 .autoclear_features = cpu_to_be64(s->autoclear_features), in qcow2_update_header()
2976 .refcount_order = cpu_to_be32(s->refcount_order), in qcow2_update_header()
2978 .compression_type = s->compression_type, in qcow2_update_header()
2982 switch (s->qcow_version) { in qcow2_update_header()
2990 ret = -EINVAL; in qcow2_update_header()
2995 buflen -= ret; in qcow2_update_header()
2999 if (s->unknown_header_fields_size) { in qcow2_update_header()
3000 if (buflen < s->unknown_header_fields_size) { in qcow2_update_header()
3001 ret = -ENOSPC; in qcow2_update_header()
3005 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size); in qcow2_update_header()
3006 buf += s->unknown_header_fields_size; in qcow2_update_header()
3007 buflen -= s->unknown_header_fields_size; in qcow2_update_header()
3011 if (s->image_backing_format) { in qcow2_update_header()
3013 s->image_backing_format, in qcow2_update_header()
3014 strlen(s->image_backing_format), in qcow2_update_header()
3021 buflen -= ret; in qcow2_update_header()
3025 if (has_data_file(bs) && s->image_data_file) { in qcow2_update_header()
3027 s->image_data_file, strlen(s->image_data_file), in qcow2_update_header()
3034 buflen -= ret; in qcow2_update_header()
3038 if (s->crypto_header.offset != 0) { in qcow2_update_header()
3039 s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset); in qcow2_update_header()
3040 s->crypto_header.length = cpu_to_be64(s->crypto_header.length); in qcow2_update_header()
3042 &s->crypto_header, sizeof(s->crypto_header), in qcow2_update_header()
3044 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset); in qcow2_update_header()
3045 s->crypto_header.length = be64_to_cpu(s->crypto_header.length); in qcow2_update_header()
3050 buflen -= ret; in qcow2_update_header()
3056 * 8-byte end-of-extension marker, that would leave only 8 bytes in qcow2_update_header()
3057 * for a backing file name in an image with 512-byte clusters. in qcow2_update_header()
3061 if (s->qcow_version >= 3 && s->cluster_size > 4096) { in qcow2_update_header()
3111 buflen -= ret; in qcow2_update_header()
3115 if (s->nb_bitmaps > 0) { in qcow2_update_header()
3117 .nb_bitmaps = cpu_to_be32(s->nb_bitmaps), in qcow2_update_header()
3119 cpu_to_be64(s->bitmap_directory_size), in qcow2_update_header()
3121 cpu_to_be64(s->bitmap_directory_offset) in qcow2_update_header()
3130 buflen -= ret; in qcow2_update_header()
3134 QLIST_FOREACH(uext, &s->unknown_header_ext, next) { in qcow2_update_header()
3135 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen); in qcow2_update_header()
3141 buflen -= ret; in qcow2_update_header()
3151 buflen -= ret; in qcow2_update_header()
3154 if (s->image_backing_file) { in qcow2_update_header()
3155 size_t backing_file_len = strlen(s->image_backing_file); in qcow2_update_header()
3158 ret = -ENOSPC; in qcow2_update_header()
3162 /* Using strncpy is ok here, since buf is not NUL-terminated. */ in qcow2_update_header()
3163 strncpy(buf, s->image_backing_file, buflen); in qcow2_update_header()
3165 header->backing_file_offset = cpu_to_be64(buf - ((char*) header)); in qcow2_update_header()
3166 header->backing_file_size = cpu_to_be32(backing_file_len); in qcow2_update_header()
3170 ret = bdrv_pwrite(bs->file, 0, s->cluster_size, header, 0); in qcow2_update_header()
3185 BDRVQcow2State *s = bs->opaque; in qcow2_co_change_backing_file()
3190 return -EINVAL; in qcow2_co_change_backing_file()
3194 return -EINVAL; in qcow2_co_change_backing_file()
3197 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), in qcow2_co_change_backing_file()
3199 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); in qcow2_co_change_backing_file()
3200 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); in qcow2_co_change_backing_file()
3202 g_free(s->image_backing_file); in qcow2_co_change_backing_file()
3203 g_free(s->image_backing_format); in qcow2_co_change_backing_file()
3205 s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL; in qcow2_co_change_backing_file()
3206 s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL; in qcow2_co_change_backing_file()
3216 BDRVQcow2State *s = bs->opaque; in qcow2_set_up_encryption()
3220 switch (cryptoopts->format) { in qcow2_set_up_encryption()
3229 return -EINVAL; in qcow2_set_up_encryption()
3232 s->crypt_method_header = fmt; in qcow2_set_up_encryption()
3239 return -EINVAL; in qcow2_set_up_encryption()
3244 error_setg_errno(errp, -ret, "Could not write encryption header"); in qcow2_set_up_encryption()
3259 * Returns: 0 on success, -errno on failure.
3265 BDRVQcow2State *s = bs->opaque; in preallocate_co()
3274 bytes = new_length - offset; in preallocate_co()
3277 cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size)); in preallocate_co()
3281 error_setg_errno(errp, -ret, "Allocating clusters failed"); in preallocate_co()
3285 for (m = meta; m != NULL; m = m->next) { in preallocate_co()
3286 m->prealloc = true; in preallocate_co()
3291 error_setg_errno(errp, -ret, "Mapping clusters failed"); in preallocate_co()
3297 bytes -= cur_bytes; in preallocate_co()
3306 file_length = bdrv_co_getlength(s->data_file->bs); in preallocate_co()
3308 error_setg_errno(errp, -file_length, "Could not get file size"); in preallocate_co()
3317 ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false, in preallocate_co()
3334 * @refcount_order: refcount bits power-of-2 exponent
3345 * Every host cluster is reference-counted, including metadata (even in qcow2_refcount_metadata_size()
3384 * @refcount_order: refcount bits power-of-2 exponent
3429 "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); in validate_cluster_size()
3473 ret = -EINVAL; in qcow2_opt_get_version_del()
3511 * We keep things simple and start with a zero-sized image. We also in qcow2_co_create()
3516 * allocating two new refcount blocks - the second of which would be at in qcow2_co_create()
3531 assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2); in qcow2_co_create()
3532 qcow2_opts = &create_options->u.qcow2; in qcow2_co_create()
3534 bs = bdrv_co_open_blockdev_ref(qcow2_opts->file, errp); in qcow2_co_create()
3536 return -EIO; in qcow2_co_create()
3540 if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) { in qcow2_co_create()
3543 ret = -EINVAL; in qcow2_co_create()
3547 if (qcow2_opts->has_version) { in qcow2_co_create()
3548 switch (qcow2_opts->version) { in qcow2_co_create()
3562 if (qcow2_opts->has_cluster_size) { in qcow2_co_create()
3563 cluster_size = qcow2_opts->cluster_size; in qcow2_co_create()
3568 if (!qcow2_opts->has_extended_l2) { in qcow2_co_create()
3569 qcow2_opts->extended_l2 = false; in qcow2_co_create()
3571 if (qcow2_opts->extended_l2) { in qcow2_co_create()
3576 ret = -EINVAL; in qcow2_co_create()
3581 if (!validate_cluster_size(cluster_size, qcow2_opts->extended_l2, errp)) { in qcow2_co_create()
3582 ret = -EINVAL; in qcow2_co_create()
3586 if (!qcow2_opts->has_preallocation) { in qcow2_co_create()
3587 qcow2_opts->preallocation = PREALLOC_MODE_OFF; in qcow2_co_create()
3589 if (qcow2_opts->backing_file && in qcow2_co_create()
3590 qcow2_opts->preallocation != PREALLOC_MODE_OFF && in qcow2_co_create()
3591 !qcow2_opts->extended_l2) in qcow2_co_create()
3595 ret = -EINVAL; in qcow2_co_create()
3598 if (qcow2_opts->has_backing_fmt && !qcow2_opts->backing_file) { in qcow2_co_create()
3600 ret = -EINVAL; in qcow2_co_create()
3604 if (!qcow2_opts->has_lazy_refcounts) { in qcow2_co_create()
3605 qcow2_opts->lazy_refcounts = false; in qcow2_co_create()
3607 if (version < 3 && qcow2_opts->lazy_refcounts) { in qcow2_co_create()
3610 ret = -EINVAL; in qcow2_co_create()
3614 if (!qcow2_opts->has_refcount_bits) { in qcow2_co_create()
3615 qcow2_opts->refcount_bits = 16; in qcow2_co_create()
3617 if (qcow2_opts->refcount_bits > 64 || in qcow2_co_create()
3618 !is_power_of_2(qcow2_opts->refcount_bits)) in qcow2_co_create()
3622 ret = -EINVAL; in qcow2_co_create()
3625 if (version < 3 && qcow2_opts->refcount_bits != 16) { in qcow2_co_create()
3629 ret = -EINVAL; in qcow2_co_create()
3632 refcount_order = ctz32(qcow2_opts->refcount_bits); in qcow2_co_create()
3634 if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) { in qcow2_co_create()
3635 error_setg(errp, "data-file-raw requires data-file"); in qcow2_co_create()
3636 ret = -EINVAL; in qcow2_co_create()
3639 if (qcow2_opts->data_file_raw && qcow2_opts->backing_file) { in qcow2_co_create()
3640 error_setg(errp, "Backing file and data-file-raw cannot be used at " in qcow2_co_create()
3642 ret = -EINVAL; in qcow2_co_create()
3645 if (qcow2_opts->data_file_raw && in qcow2_co_create()
3646 qcow2_opts->preallocation == PREALLOC_MODE_OFF) in qcow2_co_create()
3649 * data-file-raw means that "the external data file can be in qcow2_co_create()
3658 qcow2_opts->preallocation = PREALLOC_MODE_METADATA; in qcow2_co_create()
3665 assert(!qcow2_opts->backing_file); in qcow2_co_create()
3668 if (qcow2_opts->data_file) { in qcow2_co_create()
3673 ret = -EINVAL; in qcow2_co_create()
3676 data_bs = bdrv_co_open_blockdev_ref(qcow2_opts->data_file, errp); in qcow2_co_create()
3678 ret = -EIO; in qcow2_co_create()
3683 if (qcow2_opts->has_compression_type && in qcow2_co_create()
3684 qcow2_opts->compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) { in qcow2_co_create()
3686 ret = -EINVAL; in qcow2_co_create()
3689 error_setg(errp, "Non-zlib compression type is only supported with " in qcow2_co_create()
3695 switch (qcow2_opts->compression_type) { in qcow2_co_create()
3705 compression_type = qcow2_opts->compression_type; in qcow2_co_create()
3712 ret = -EPERM; in qcow2_co_create()
3736 header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); in qcow2_co_create()
3738 if (qcow2_opts->lazy_refcounts) { in qcow2_co_create()
3739 header->compatible_features |= in qcow2_co_create()
3743 header->incompatible_features |= in qcow2_co_create()
3746 if (qcow2_opts->data_file_raw) { in qcow2_co_create()
3747 header->autoclear_features |= in qcow2_co_create()
3751 header->incompatible_features |= in qcow2_co_create()
3755 if (qcow2_opts->extended_l2) { in qcow2_co_create()
3756 header->incompatible_features |= in qcow2_co_create()
3763 error_setg_errno(errp, -ret, "Could not write qcow2 header"); in qcow2_co_create()
3774 error_setg_errno(errp, -ret, "Could not write refcount table"); in qcow2_co_create()
3788 qdict_put_str(options, "file", bs->node_name); in qcow2_co_create()
3790 qdict_put_str(options, "data-file", data_bs->node_name); in qcow2_co_create()
3796 ret = -EIO; in qcow2_co_create()
3804 error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 " in qcow2_co_create()
3815 BDRVQcow2State *s = blk_bs(blk)->opaque; in qcow2_co_create()
3816 s->image_data_file = g_strdup(data_bs->filename); in qcow2_co_create()
3824 error_setg_errno(errp, -ret, "Could not update qcow2 header"); in qcow2_co_create()
3829 ret = blk_co_truncate(blk, qcow2_opts->size, false, in qcow2_co_create()
3830 qcow2_opts->preallocation, 0, errp); in qcow2_co_create()
3837 if (qcow2_opts->backing_file) { in qcow2_co_create()
3840 if (qcow2_opts->has_backing_fmt) { in qcow2_co_create()
3841 backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt); in qcow2_co_create()
3845 ret = bdrv_co_change_backing_file(blk_bs(blk), qcow2_opts->backing_file, in qcow2_co_create()
3850 error_setg_errno(errp, -ret, "Could not assign backing file '%s' " in qcow2_co_create()
3851 "with format '%s'", qcow2_opts->backing_file, in qcow2_co_create()
3858 if (qcow2_opts->encrypt) { in qcow2_co_create()
3860 ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp); in qcow2_co_create()
3879 qdict_put_str(options, "file", bs->node_name); in qcow2_co_create()
3881 qdict_put_str(options, "data-file", data_bs->node_name); in qcow2_co_create()
3887 ret = -EIO; in qcow2_co_create()
3942 { BLOCK_OPT_BACKING_FILE, "backing-file" }, in qcow2_co_create_opts()
3943 { BLOCK_OPT_BACKING_FMT, "backing-fmt" }, in qcow2_co_create_opts()
3944 { BLOCK_OPT_CLUSTER_SIZE, "cluster-size" }, in qcow2_co_create_opts()
3945 { BLOCK_OPT_LAZY_REFCOUNTS, "lazy-refcounts" }, in qcow2_co_create_opts()
3946 { BLOCK_OPT_EXTL2, "extended-l2" }, in qcow2_co_create_opts()
3947 { BLOCK_OPT_REFCOUNT_BITS, "refcount-bits" }, in qcow2_co_create_opts()
3950 { BLOCK_OPT_DATA_FILE_RAW, "data-file-raw" }, in qcow2_co_create_opts()
3951 { BLOCK_OPT_COMPRESSION_TYPE, "compression-type" }, in qcow2_co_create_opts()
3956 ret = -EINVAL; in qcow2_co_create_opts()
3969 ret = -EIO; in qcow2_co_create_opts()
3985 ret = -EIO; in qcow2_co_create_opts()
3990 qdict_put_str(qdict, "data-file", data_bs->node_name); in qcow2_co_create_opts()
3995 qdict_put_str(qdict, "file", bs->node_name); in qcow2_co_create_opts()
4000 ret = -EINVAL; in qcow2_co_create_opts()
4007 ret = -EINVAL; in qcow2_co_create_opts()
4012 create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size, in qcow2_co_create_opts()
4042 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) { in is_zero()
4043 bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset; in is_zero()
4059 bytes -= nr; in is_zero()
4070 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwrite_zeroes()
4073 uint32_t tail = ROUND_UP(offset + bytes, s->subcluster_size) - in qcow2_co_pwrite_zeroes()
4077 if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) { in qcow2_co_pwrite_zeroes()
4086 assert(head + bytes + tail <= s->subcluster_size); in qcow2_co_pwrite_zeroes()
4089 if (!(is_zero(bs, offset - head, head) && in qcow2_co_pwrite_zeroes()
4091 return -ENOTSUP; in qcow2_co_pwrite_zeroes()
4094 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwrite_zeroes()
4096 offset -= head; in qcow2_co_pwrite_zeroes()
4097 bytes = s->subcluster_size; in qcow2_co_pwrite_zeroes()
4098 nr = s->subcluster_size; in qcow2_co_pwrite_zeroes()
4105 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwrite_zeroes()
4106 return ret < 0 ? ret : -ENOTSUP; in qcow2_co_pwrite_zeroes()
4109 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwrite_zeroes()
4116 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwrite_zeroes()
4125 BDRVQcow2State *s = bs->opaque; in qcow2_co_pdiscard()
4129 if (s->qcow_version < 3 && bs->backing) { in qcow2_co_pdiscard()
4130 return -ENOTSUP; in qcow2_co_pdiscard()
4133 if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) { in qcow2_co_pdiscard()
4134 assert(bytes < s->cluster_size); in qcow2_co_pdiscard()
4137 if (!QEMU_IS_ALIGNED(offset, s->cluster_size) || in qcow2_co_pdiscard()
4138 offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) { in qcow2_co_pdiscard()
4139 return -ENOTSUP; in qcow2_co_pdiscard()
4143 qemu_co_mutex_lock(&s->lock); in qcow2_co_pdiscard()
4146 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pdiscard()
4157 BDRVQcow2State *s = bs->opaque; in qcow2_co_copy_range_from()
4163 assert(!bs->encrypted); in qcow2_co_copy_range_from()
4164 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_from()
4182 if (bs->backing && bs->backing->bs) { in qcow2_co_copy_range_from()
4183 int64_t backing_length = bdrv_co_getlength(bs->backing->bs); in qcow2_co_copy_range_from()
4187 child = bs->backing; in qcow2_co_copy_range_from()
4188 cur_bytes = MIN(cur_bytes, backing_length - src_offset); in qcow2_co_copy_range_from()
4202 ret = -ENOTSUP; in qcow2_co_copy_range_from()
4206 child = s->data_file; in qcow2_co_copy_range_from()
4212 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_from()
4217 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_from()
4222 bytes -= cur_bytes; in qcow2_co_copy_range_from()
4229 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_from()
4240 BDRVQcow2State *s = bs->opaque; in qcow2_co_copy_range_to()
4246 assert(!bs->encrypted); in qcow2_co_copy_range_to()
4248 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_to()
4257 * If src->bs == dst->bs, we could simply copy by incrementing in qcow2_co_copy_range_to()
4259 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */ in qcow2_co_copy_range_to()
4272 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_to()
4273 ret = bdrv_co_copy_range_to(src, src_offset, s->data_file, host_offset, in qcow2_co_copy_range_to()
4275 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_to()
4285 bytes -= cur_bytes; in qcow2_co_copy_range_to()
4294 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_to()
4306 BDRVQcow2State *s = bs->opaque; in qcow2_co_truncate()
4317 return -ENOTSUP; in qcow2_co_truncate()
4323 return -EINVAL; in qcow2_co_truncate()
4326 qemu_co_mutex_lock(&s->lock); in qcow2_co_truncate()
4332 if (s->nb_snapshots && s->qcow_version < 3) { in qcow2_co_truncate()
4334 ret = -ENOTSUP; in qcow2_co_truncate()
4338 /* See qcow2-bitmap.c for which bitmap scenarios prevent a resize. */ in qcow2_co_truncate()
4340 ret = -ENOTSUP; in qcow2_co_truncate()
4344 old_length = bs->total_sectors * BDRV_SECTOR_SIZE; in qcow2_co_truncate()
4352 ret = -EINVAL; in qcow2_co_truncate()
4356 ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size), in qcow2_co_truncate()
4357 old_length - ROUND_UP(offset, in qcow2_co_truncate()
4358 s->cluster_size), in qcow2_co_truncate()
4361 error_setg_errno(errp, -ret, "Failed to discard cropped clusters"); in qcow2_co_truncate()
4367 error_setg_errno(errp, -ret, in qcow2_co_truncate()
4374 error_setg_errno(errp, -ret, in qcow2_co_truncate()
4379 old_file_size = bdrv_co_getlength(bs->file->bs); in qcow2_co_truncate()
4381 error_setg_errno(errp, -old_file_size, in qcow2_co_truncate()
4388 error_setg_errno(errp, -last_cluster, in qcow2_co_truncate()
4393 if ((last_cluster + 1) * s->cluster_size < old_file_size) { in qcow2_co_truncate()
4399 * their qcow2 image (on a block device) with qemu-img. in qcow2_co_truncate()
4403 bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size, in qcow2_co_truncate()
4413 error_setg_errno(errp, -ret, "Failed to grow the L1 table"); in qcow2_co_truncate()
4419 * When creating a qcow2 image with data-file-raw, we enforce in qcow2_co_truncate()
4438 ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0, in qcow2_co_truncate()
4472 old_file_size = bdrv_co_getlength(bs->file->bs); in qcow2_co_truncate()
4474 error_setg_errno(errp, -old_file_size, in qcow2_co_truncate()
4482 old_file_size = (last_cluster + 1) * s->cluster_size; in qcow2_co_truncate()
4484 old_file_size = ROUND_UP(old_file_size, s->cluster_size); in qcow2_co_truncate()
4487 nb_new_data_clusters = (ROUND_UP(offset, s->cluster_size) - in qcow2_co_truncate()
4488 start_of_cluster(s, old_length)) >> s->cluster_bits; in qcow2_co_truncate()
4501 s->cluster_size / l2_entry_size(s)); in qcow2_co_truncate()
4511 error_setg_errno(errp, -allocation_start, in qcow2_co_truncate()
4520 error_setg_errno(errp, -clusters_allocated, in qcow2_co_truncate()
4530 nb_new_data_clusters * s->cluster_size; in qcow2_co_truncate()
4538 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, in qcow2_co_truncate()
4546 ret = -1; in qcow2_co_truncate()
4549 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0, in qcow2_co_truncate()
4555 nb_new_data_clusters * s->cluster_size, in qcow2_co_truncate()
4566 s->l2_slice_size - offset_to_l2_slice_index(s, guest_offset)); in qcow2_co_truncate()
4579 .offset = nb_clusters << s->cluster_bits, in qcow2_co_truncate()
4588 error_setg_errno(errp, -ret, "Failed to update L2 tables"); in qcow2_co_truncate()
4590 nb_new_data_clusters * s->cluster_size, in qcow2_co_truncate()
4595 guest_offset += nb_clusters * s->cluster_size; in qcow2_co_truncate()
4596 host_offset += nb_clusters * s->cluster_size; in qcow2_co_truncate()
4597 nb_new_data_clusters -= nb_clusters; in qcow2_co_truncate()
4607 uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->subcluster_size); in qcow2_co_truncate()
4611 * requires a subcluster-aligned start. The end may be unaligned if in qcow2_co_truncate()
4615 ret = qcow2_subcluster_zeroize(bs, zero_start, offset - zero_start, in qcow2_co_truncate()
4618 error_setg_errno(errp, -ret, "Failed to zero out new clusters"); in qcow2_co_truncate()
4625 uint64_t len = MIN(zero_start, offset) - old_length; in qcow2_co_truncate()
4630 qemu_co_mutex_unlock(&s->lock); in qcow2_co_truncate()
4632 qemu_co_mutex_lock(&s->lock); in qcow2_co_truncate()
4636 error_setg_errno(errp, -ret, "Failed to zero out the new area"); in qcow2_co_truncate()
4646 error_setg_errno(errp, -ret, in qcow2_co_truncate()
4652 bs->total_sectors = offset / BDRV_SECTOR_SIZE; in qcow2_co_truncate()
4656 ret = bdrv_co_pwrite_sync(bs->file, offsetof(QCowHeader, size), in qcow2_co_truncate()
4659 error_setg_errno(errp, -ret, "Failed to update the image size"); in qcow2_co_truncate()
4663 s->l1_vm_state_index = new_l1_size; in qcow2_co_truncate()
4666 options = qdict_clone_shallow(bs->options); in qcow2_co_truncate()
4667 ret = qcow2_update_options(bs, options, s->flags, errp); in qcow2_co_truncate()
4674 qemu_co_mutex_unlock(&s->lock); in qcow2_co_truncate()
4683 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwritev_compressed_task()
4689 assert(bytes == s->cluster_size || (bytes < s->cluster_size && in qcow2_co_pwritev_compressed_task()
4690 (offset + bytes == bs->total_sectors << BDRV_SECTOR_BITS))); in qcow2_co_pwritev_compressed_task()
4692 buf = qemu_blockalign(bs, s->cluster_size); in qcow2_co_pwritev_compressed_task()
4693 if (bytes < s->cluster_size) { in qcow2_co_pwritev_compressed_task()
4694 /* Zero-pad last write if image size is not cluster aligned */ in qcow2_co_pwritev_compressed_task()
4695 memset(buf + bytes, 0, s->cluster_size - bytes); in qcow2_co_pwritev_compressed_task()
4699 out_buf = g_malloc(s->cluster_size); in qcow2_co_pwritev_compressed_task()
4701 out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1, in qcow2_co_pwritev_compressed_task()
4702 buf, s->cluster_size); in qcow2_co_pwritev_compressed_task()
4703 if (out_len == -ENOMEM) { in qcow2_co_pwritev_compressed_task()
4711 ret = -EINVAL; in qcow2_co_pwritev_compressed_task()
4715 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwritev_compressed_task()
4719 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwritev_compressed_task()
4724 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwritev_compressed_task()
4729 BLKDBG_CO_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED); in qcow2_co_pwritev_compressed_task()
4730 ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0); in qcow2_co_pwritev_compressed_task()
4745 * this coroutine has terminated.
4752 assert(!t->subcluster_type && !t->l2meta); in qcow2_co_pwritev_compressed_task_entry()
4754 return qcow2_co_pwritev_compressed_task(t->bs, t->offset, t->bytes, t->qiov, in qcow2_co_pwritev_compressed_task_entry()
4755 t->qiov_offset); in qcow2_co_pwritev_compressed_task_entry()
4767 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwritev_compressed_part()
4772 return -ENOTSUP; in qcow2_co_pwritev_compressed_part()
4780 int64_t len = bdrv_co_getlength(bs->file->bs); in qcow2_co_pwritev_compressed_part()
4784 return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0, in qcow2_co_pwritev_compressed_part()
4789 return -EINVAL; in qcow2_co_pwritev_compressed_part()
4793 (offset + bytes) != (bs->total_sectors << BDRV_SECTOR_BITS)) { in qcow2_co_pwritev_compressed_part()
4794 return -EINVAL; in qcow2_co_pwritev_compressed_part()
4798 uint64_t chunk_size = MIN(bytes, s->cluster_size); in qcow2_co_pwritev_compressed_part()
4811 bytes -= chunk_size; in qcow2_co_pwritev_compressed_part()
4833 BDRVQcow2State *s = bs->opaque; in qcow2_co_preadv_compressed()
4843 return -ENOMEM; in qcow2_co_preadv_compressed()
4846 out_buf = qemu_blockalign(bs, s->cluster_size); in qcow2_co_preadv_compressed()
4848 BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_COMPRESSED); in qcow2_co_preadv_compressed()
4849 ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0); in qcow2_co_preadv_compressed()
4854 if (qcow2_co_decompress(bs, out_buf, s->cluster_size, buf, csize) < 0) { in qcow2_co_preadv_compressed()
4855 ret = -EIO; in qcow2_co_preadv_compressed()
4870 BDRVQcow2State *s = bs->opaque; in make_completely_empty()
4882 ret = qcow2_cache_empty(bs, s->l2_table_cache); in make_completely_empty()
4887 ret = qcow2_cache_empty(bs, s->refcount_block_cache); in make_completely_empty()
4898 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); in make_completely_empty()
4900 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE); in make_completely_empty()
4901 l1_size2 = (uint64_t)s->l1_size * L1E_SIZE; in make_completely_empty()
4903 /* After this call, neither the in-memory nor the on-disk refcount in make_completely_empty()
4906 ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset, in make_completely_empty()
4907 l1_clusters * s->cluster_size, 0); in make_completely_empty()
4911 memset(s->l1_table, 0, l1_size2); in make_completely_empty()
4913 BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE); in make_completely_empty()
4920 ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size, in make_completely_empty()
4921 (2 + l1_clusters) * s->cluster_size, 0); in make_completely_empty()
4922 /* This call (even if it failed overall) may have overwritten on-disk in make_completely_empty()
4923 * refcount structures; in that case, the in-memory refcount information in make_completely_empty()
4924 * will probably differ from the on-disk information which makes the BDS in make_completely_empty()
4930 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); in make_completely_empty()
4931 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE); in make_completely_empty()
4936 l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size); in make_completely_empty()
4937 l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size); in make_completely_empty()
4939 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset), in make_completely_empty()
4945 s->l1_table_offset = 3 * s->cluster_size; in make_completely_empty()
4947 new_reftable = g_try_new0(uint64_t, s->cluster_size / REFTABLE_ENTRY_SIZE); in make_completely_empty()
4949 ret = -ENOMEM; in make_completely_empty()
4953 s->refcount_table_offset = s->cluster_size; in make_completely_empty()
4954 s->refcount_table_size = s->cluster_size / REFTABLE_ENTRY_SIZE; in make_completely_empty()
4955 s->max_refcount_table_index = 0; in make_completely_empty()
4957 g_free(s->refcount_table); in make_completely_empty()
4958 s->refcount_table = new_reftable; in make_completely_empty()
4961 /* Now the in-memory refcount information again corresponds to the on-disk in make_completely_empty()
4965 * the in-memory information is always correct */ in make_completely_empty()
4967 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); in make_completely_empty()
4970 rt_entry = cpu_to_be64(2 * s->cluster_size); in make_completely_empty()
4971 ret = bdrv_pwrite_sync(bs->file, s->cluster_size, sizeof(rt_entry), in make_completely_empty()
4976 s->refcount_table[0] = 2 * s->cluster_size; in make_completely_empty()
4978 s->free_cluster_index = 0; in make_completely_empty()
4979 assert(3 + l1_clusters <= s->refcount_block_size); in make_completely_empty()
4980 offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2); in make_completely_empty()
4989 /* Now finally the in-memory information corresponds to the on-disk in make_completely_empty()
4996 ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false, in make_completely_empty()
5012 bs->drv = NULL; in make_completely_empty()
5021 BDRVQcow2State *s = bs->opaque; in qcow2_make_empty()
5023 int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size); in qcow2_make_empty()
5026 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE); in qcow2_make_empty()
5028 if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps && in qcow2_make_empty()
5029 3 + l1_clusters <= s->refcount_block_size && in qcow2_make_empty()
5030 s->crypt_method_header != QCOW_CRYPT_LUKS && in qcow2_make_empty()
5046 end_offset = bs->total_sectors * BDRV_SECTOR_SIZE; in qcow2_make_empty()
5053 ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset), in qcow2_make_empty()
5065 BDRVQcow2State *s = bs->opaque; in qcow2_co_flush_to_os()
5068 qemu_co_mutex_lock(&s->lock); in qcow2_co_flush_to_os()
5070 qemu_co_mutex_unlock(&s->lock); in qcow2_co_flush_to_os()
5167 error_setg_errno(&local_err, -ssize, in qcow2_measure()
5189 ssize - offset, &pnum, NULL, in qcow2_measure()
5192 error_setg_errno(&local_err, -ret, in qcow2_measure()
5202 pnum = ROUND_UP(offset + pnum, cluster_size) - offset; in qcow2_measure()
5219 info->fully_allocated = luks_payload_size + in qcow2_measure()
5229 info->required = info->fully_allocated - virtual_size + required; in qcow2_measure()
5230 info->has_bitmaps = version >= 3 && in_bs && in qcow2_measure()
5232 if (info->has_bitmaps) { in qcow2_measure()
5233 info->bitmaps = qcow2_get_persistent_dirty_bitmap_size(in_bs, in qcow2_measure()
5246 BDRVQcow2State *s = bs->opaque; in qcow2_co_get_info()
5247 bdi->cluster_size = s->cluster_size; in qcow2_co_get_info()
5248 bdi->subcluster_size = s->subcluster_size; in qcow2_co_get_info()
5249 bdi->vm_state_offset = qcow2_vm_state_offset(s); in qcow2_co_get_info()
5250 bdi->is_dirty = s->incompatible_features & QCOW2_INCOMPAT_DIRTY; in qcow2_co_get_info()
5257 BDRVQcow2State *s = bs->opaque; in qcow2_get_specific_info()
5261 if (s->crypto != NULL) { in qcow2_get_specific_info()
5262 encrypt_info = qcrypto_block_get_info(s->crypto, errp); in qcow2_get_specific_info()
5273 if (s->qcow_version == 2) { in qcow2_get_specific_info()
5274 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ in qcow2_get_specific_info()
5276 .refcount_bits = s->refcount_bits, in qcow2_get_specific_info()
5278 } else if (s->qcow_version == 3) { in qcow2_get_specific_info()
5285 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ in qcow2_get_specific_info()
5287 .lazy_refcounts = s->compatible_features & in qcow2_get_specific_info()
5290 .corrupt = s->incompatible_features & in qcow2_get_specific_info()
5295 .refcount_bits = s->refcount_bits, in qcow2_get_specific_info()
5298 .data_file = g_strdup(s->image_data_file), in qcow2_get_specific_info()
5301 .compression_type = s->compression_type, in qcow2_get_specific_info()
5312 switch (encrypt_info->format) { in qcow2_get_specific_info()
5314 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES; in qcow2_get_specific_info()
5317 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS; in qcow2_get_specific_info()
5318 qencrypt->u.luks = encrypt_info->u.luks; in qcow2_get_specific_info()
5325 memset(&encrypt_info->u, 0, sizeof(encrypt_info->u)); in qcow2_get_specific_info()
5328 spec_info->u.qcow2.data->encrypt = qencrypt; in qcow2_get_specific_info()
5337 BDRVQcow2State *s = bs->opaque; in qcow2_has_zero_init()
5341 qemu_co_mutex_lock(&s->lock); in qcow2_has_zero_init()
5348 preallocated = s->l1_size > 0 && s->l1_table[0] != 0; in qcow2_has_zero_init()
5350 qemu_co_mutex_unlock(&s->lock); in qcow2_has_zero_init()
5355 } else if (bs->encrypted) { in qcow2_has_zero_init()
5358 return bdrv_has_zero_init(s->data_file->bs); in qcow2_has_zero_init()
5369 BDRVQcow2State *s = bs->opaque; in qcow2_check_vmstate_request()
5374 bdrv_check_qiov_request(pos, qiov->size, qiov, 0, &error_abort); in qcow2_check_vmstate_request()
5376 if (INT64_MAX - pos < vmstate_offset) { in qcow2_check_vmstate_request()
5377 return -EIO; in qcow2_check_vmstate_request()
5381 ret = bdrv_check_qiov_request(pos, qiov->size, qiov, 0, NULL); in qcow2_check_vmstate_request()
5397 BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); in qcow2_co_save_vmstate()
5398 return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0); in qcow2_co_save_vmstate()
5409 BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); in qcow2_co_load_vmstate()
5410 return bs->drv->bdrv_co_preadv_part(bs, offset, qiov->size, qiov, 0, 0); in qcow2_co_load_vmstate()
5439 bytes -= cur_bytes; in qcow2_has_compressed_clusters()
5454 BDRVQcow2State *s = bs->opaque; in qcow2_downgrade()
5455 int current_version = s->qcow_version; in qcow2_downgrade()
5465 if (s->refcount_order != 4) { in qcow2_downgrade()
5467 return -ENOTSUP; in qcow2_downgrade()
5472 return -ENOTSUP; in qcow2_downgrade()
5478 * is unsafe. Even though we would still use v3-compliant output in qcow2_downgrade()
5482 for (i = 0; i < s->nb_snapshots; i++) { in qcow2_downgrade()
5483 if (s->snapshots[i].vm_state_size > UINT32_MAX || in qcow2_downgrade()
5484 s->snapshots[i].disk_size != bs->total_sectors * BDRV_SECTOR_SIZE) { in qcow2_downgrade()
5486 return -ENOTSUP; in qcow2_downgrade()
5491 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { in qcow2_downgrade()
5494 error_setg_errno(errp, -ret, "Failed to make the image clean"); in qcow2_downgrade()
5500 * the first place; if that happens nonetheless, returning -ENOTSUP is the in qcow2_downgrade()
5503 if (s->incompatible_features & ~QCOW2_INCOMPAT_COMPRESSION) { in qcow2_downgrade()
5506 s->incompatible_features & ~QCOW2_INCOMPAT_COMPRESSION); in qcow2_downgrade()
5507 return -ENOTSUP; in qcow2_downgrade()
5511 s->compatible_features = 0; in qcow2_downgrade()
5516 s->autoclear_features = 0; in qcow2_downgrade()
5520 error_setg_errno(errp, -ret, "Failed to turn zero into data clusters"); in qcow2_downgrade()
5524 if (s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION) { in qcow2_downgrade()
5528 return -EINVAL; in qcow2_downgrade()
5533 return -ENOTSUP; in qcow2_downgrade()
5539 s->incompatible_features &= ~QCOW2_INCOMPAT_COMPRESSION; in qcow2_downgrade()
5540 s->compression_type = QCOW2_COMPRESSION_TYPE_ZLIB; in qcow2_downgrade()
5543 assert(s->incompatible_features == 0); in qcow2_downgrade()
5545 s->qcow_version = target_version; in qcow2_downgrade()
5548 s->qcow_version = current_version; in qcow2_downgrade()
5549 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_downgrade()
5565 BDRVQcow2State *s = bs->opaque; in qcow2_upgrade()
5567 int current_version = s->qcow_version; in qcow2_upgrade()
5581 * the 64-bit VM state size and the virtual disk size to be in qcow2_upgrade()
5584 * v3-compliant format. in qcow2_upgrade()
5587 for (i = 0; i < s->nb_snapshots; i++) { in qcow2_upgrade()
5588 if (s->snapshots[i].extra_data_size < in qcow2_upgrade()
5599 error_setg_errno(errp, -ret, "Failed to update the snapshot table"); in qcow2_upgrade()
5605 s->qcow_version = target_version; in qcow2_upgrade()
5608 s->qcow_version = current_version; in qcow2_upgrade()
5609 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_upgrade()
5660 if (info->current_operation != info->last_operation) { in qcow2_amend_helper_cb()
5661 if (info->last_operation != QCOW2_NO_OPERATION) { in qcow2_amend_helper_cb()
5662 info->offset_completed += info->last_work_size; in qcow2_amend_helper_cb()
5663 info->operations_completed++; in qcow2_amend_helper_cb()
5666 info->last_operation = info->current_operation; in qcow2_amend_helper_cb()
5669 assert(info->total_operations > 0); in qcow2_amend_helper_cb()
5670 assert(info->operations_completed < info->total_operations); in qcow2_amend_helper_cb()
5672 info->last_work_size = operation_work_size; in qcow2_amend_helper_cb()
5674 current_work_size = info->offset_completed + operation_work_size; in qcow2_amend_helper_cb()
5680 projected_work_size = current_work_size * (info->total_operations - in qcow2_amend_helper_cb()
5681 info->operations_completed - 1) in qcow2_amend_helper_cb()
5682 / (info->operations_completed + 1); in qcow2_amend_helper_cb()
5684 info->original_status_cb(bs, info->offset_completed + operation_offset, in qcow2_amend_helper_cb()
5686 info->original_cb_opaque); in qcow2_amend_helper_cb()
5694 BDRVQcow2State *s = bs->opaque; in qcow2_amend_options()
5695 int old_version = s->qcow_version, new_version = old_version; in qcow2_amend_options()
5698 bool lazy_refcounts = s->use_lazy_refcounts; in qcow2_amend_options()
5701 int refcount_bits = s->refcount_bits; in qcow2_amend_options()
5703 QemuOptDesc *desc = opts->list->desc; in qcow2_amend_options()
5707 while (desc && desc->name) { in qcow2_amend_options()
5708 if (!qemu_opt_find(opts, desc->name)) { in qcow2_amend_options()
5714 if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) { in qcow2_amend_options()
5724 return -EINVAL; in qcow2_amend_options()
5726 } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) { in qcow2_amend_options()
5728 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) { in qcow2_amend_options()
5730 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) { in qcow2_amend_options()
5732 } else if (g_str_has_prefix(desc->name, "encrypt.")) { in qcow2_amend_options()
5733 if (!s->crypto) { in qcow2_amend_options()
5735 "Can't amend encryption options - encryption not present"); in qcow2_amend_options()
5736 return -EINVAL; in qcow2_amend_options()
5738 if (s->crypt_method_header != QCOW_CRYPT_LUKS) { in qcow2_amend_options()
5741 return -ENOTSUP; in qcow2_amend_options()
5744 } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) { in qcow2_amend_options()
5747 } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) { in qcow2_amend_options()
5756 return -EINVAL; in qcow2_amend_options()
5758 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE)) { in qcow2_amend_options()
5761 error_setg(errp, "data-file can only be set for images that " in qcow2_amend_options()
5763 return -EINVAL; in qcow2_amend_options()
5765 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE_RAW)) { in qcow2_amend_options()
5769 error_setg(errp, "data-file-raw cannot be set on existing " in qcow2_amend_options()
5771 return -EINVAL; in qcow2_amend_options()
5786 + (s->refcount_bits != refcount_bits) + in qcow2_amend_options()
5807 return -EINVAL; in qcow2_amend_options()
5812 return -EINVAL; in qcow2_amend_options()
5814 ret = qcrypto_block_amend_options(s->crypto, in qcow2_amend_options()
5827 if (s->refcount_bits != refcount_bits) { in qcow2_amend_options()
5834 return -EINVAL; in qcow2_amend_options()
5846 /* data-file-raw blocks backing files, so clear it first if requested */ in qcow2_amend_options()
5848 s->autoclear_features |= QCOW2_AUTOCLEAR_DATA_FILE_RAW; in qcow2_amend_options()
5850 s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW; in qcow2_amend_options()
5854 g_free(s->image_data_file); in qcow2_amend_options()
5855 s->image_data_file = *data_file ? g_strdup(data_file) : NULL; in qcow2_amend_options()
5860 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_amend_options()
5865 if (g_strcmp0(backing_file, s->image_backing_file) || in qcow2_amend_options()
5866 g_strcmp0(backing_format, s->image_backing_format)) { in qcow2_amend_options()
5869 "You can use 'qemu-img rebase' instead.\n"); in qcow2_amend_options()
5870 return -EINVAL; in qcow2_amend_options()
5874 if (s->use_lazy_refcounts != lazy_refcounts) { in qcow2_amend_options()
5880 return -EINVAL; in qcow2_amend_options()
5882 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5885 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5886 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_amend_options()
5889 s->use_lazy_refcounts = true; in qcow2_amend_options()
5894 error_setg_errno(errp, -ret, "Failed to make the image clean"); in qcow2_amend_options()
5898 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5901 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5902 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_amend_options()
5905 s->use_lazy_refcounts = false; in qcow2_amend_options()
5913 return -EPERM; in qcow2_amend_options()
5945 BlockdevAmendOptionsQcow2 *qopts = &opts->u.qcow2; in qcow2_co_amend()
5946 BDRVQcow2State *s = bs->opaque; in qcow2_co_amend()
5949 if (qopts->encrypt) { in qcow2_co_amend()
5950 if (!s->crypto) { in qcow2_co_amend()
5952 return -EOPNOTSUPP; in qcow2_co_amend()
5955 if (qopts->encrypt->format != QCRYPTO_BLOCK_FORMAT_LUKS) { in qcow2_co_amend()
5958 return -EOPNOTSUPP; in qcow2_co_amend()
5961 if (s->crypt_method_header != QCOW_CRYPT_LUKS) { in qcow2_co_amend()
5963 "Only LUKS encryption options can be amended for qcow2 with blockdev-amend"); in qcow2_co_amend()
5964 return -EOPNOTSUPP; in qcow2_co_amend()
5967 ret = qcrypto_block_amend_options(s->crypto, in qcow2_co_amend()
5971 qopts->encrypt, in qcow2_co_amend()
5981 * fatal will be ignored for read-only BDS; corruptions found there will always
5982 * be considered non-fatal.
5987 BDRVQcow2State *s = bs->opaque; in qcow2_signal_corruption()
5994 if (s->signaled_corruption && in qcow2_signal_corruption()
5995 (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT))) in qcow2_signal_corruption()
6008 fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal " in qcow2_signal_corruption()
6022 bs->drv = NULL; /* make BDS unusable */ in qcow2_signal_corruption()
6025 s->signaled_corruption = true; in qcow2_signal_corruption()
6074 .name = "qcow2-create-opts",
6127 .name = "qcow2-amend-opts",