Lines Matching +full:role +full:- +full:switch +full:- +full:default +full:- +full:mode
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()
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()
250 switch (ext.magic) { 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()
435 default: 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()
951 * default to 4KB entries. Smaller entries reduce the cost of 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()
1202 default: 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()
1290 default: 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()
1438 * the only valid (default) compression type in that case 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()
1765 * Internal snapshots; skip reading them in check mode, because 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()
1790 * 1. Normal open of the disk in active mode, not related to invalidation 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()
1840 * 4. Open disk in inactive mode in target vm (bitmaps are migrating or 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()
2146 qcow2_co_block_status(BlockDriverState *bs, unsigned int mode, in qcow2_co_block_status() argument
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()
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()
2338 switch (subc_type) { 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()
2366 default: in qcow2_co_preadv_task()
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()
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()
2827 bdrv_unref_child(bs, s->data_file); in qcow2_do_close()
2829 s->data_file = NULL; in qcow2_do_close()
2849 BDRVQcow2State *s = bs->opaque; in qcow2_co_invalidate_cache()
2851 int flags = s->flags; in qcow2_co_invalidate_cache()
2857 * Backing files are read-only which makes all of their metadata immutable, in qcow2_co_invalidate_cache()
2861 crypto = s->crypto; in qcow2_co_invalidate_cache()
2862 s->crypto = NULL; in qcow2_co_invalidate_cache()
2865 * Do not reopen s->data_file (i.e., have qcow2_do_close() not close it, in qcow2_co_invalidate_cache()
2867 * runs in the I/O path and as such we must not invoke global-state in qcow2_co_invalidate_cache()
2873 data_file = s->data_file; in qcow2_co_invalidate_cache()
2875 s->data_file = data_file; in qcow2_co_invalidate_cache()
2877 options = qdict_clone_shallow(bs->options); in qcow2_co_invalidate_cache()
2880 qemu_co_mutex_lock(&s->lock); in qcow2_co_invalidate_cache()
2882 qemu_co_mutex_unlock(&s->lock); in qcow2_co_invalidate_cache()
2886 bs->drv = NULL; in qcow2_co_invalidate_cache()
2890 s->crypto = crypto; in qcow2_co_invalidate_cache()
2900 return -ENOSPC; in header_ext_add()
2921 * Returns 0 on success, -errno in error cases.
2925 BDRVQcow2State *s = bs->opaque; in qcow2_update_header()
2928 size_t buflen = s->cluster_size; in qcow2_update_header()
2941 ret = -ENOSPC; in qcow2_update_header()
2945 header_length = sizeof(*header) + s->unknown_header_fields_size; in qcow2_update_header()
2946 total_size = bs->total_sectors * BDRV_SECTOR_SIZE; in qcow2_update_header()
2947 refcount_table_clusters = s->refcount_table_size >> (s->cluster_bits - 3); in qcow2_update_header()
2957 .version = cpu_to_be32(s->qcow_version), in qcow2_update_header()
2960 .cluster_bits = cpu_to_be32(s->cluster_bits), in qcow2_update_header()
2962 .crypt_method = cpu_to_be32(s->crypt_method_header), in qcow2_update_header()
2963 .l1_size = cpu_to_be32(s->l1_size), in qcow2_update_header()
2964 .l1_table_offset = cpu_to_be64(s->l1_table_offset), in qcow2_update_header()
2965 .refcount_table_offset = cpu_to_be64(s->refcount_table_offset), in qcow2_update_header()
2967 .nb_snapshots = cpu_to_be32(s->nb_snapshots), in qcow2_update_header()
2968 .snapshots_offset = cpu_to_be64(s->snapshots_offset), in qcow2_update_header()
2971 .incompatible_features = cpu_to_be64(s->incompatible_features), in qcow2_update_header()
2972 .compatible_features = cpu_to_be64(s->compatible_features), in qcow2_update_header()
2973 .autoclear_features = cpu_to_be64(s->autoclear_features), in qcow2_update_header()
2974 .refcount_order = cpu_to_be32(s->refcount_order), in qcow2_update_header()
2976 .compression_type = s->compression_type, in qcow2_update_header()
2980 switch (s->qcow_version) { in qcow2_update_header()
2987 default: in qcow2_update_header()
2988 ret = -EINVAL; in qcow2_update_header()
2993 buflen -= ret; in qcow2_update_header()
2997 if (s->unknown_header_fields_size) { in qcow2_update_header()
2998 if (buflen < s->unknown_header_fields_size) { in qcow2_update_header()
2999 ret = -ENOSPC; in qcow2_update_header()
3003 memcpy(buf, s->unknown_header_fields, s->unknown_header_fields_size); in qcow2_update_header()
3004 buf += s->unknown_header_fields_size; in qcow2_update_header()
3005 buflen -= s->unknown_header_fields_size; in qcow2_update_header()
3009 if (s->image_backing_format) { in qcow2_update_header()
3011 s->image_backing_format, in qcow2_update_header()
3012 strlen(s->image_backing_format), in qcow2_update_header()
3019 buflen -= ret; in qcow2_update_header()
3023 if (has_data_file(bs) && s->image_data_file) { in qcow2_update_header()
3025 s->image_data_file, strlen(s->image_data_file), in qcow2_update_header()
3032 buflen -= ret; in qcow2_update_header()
3036 if (s->crypto_header.offset != 0) { in qcow2_update_header()
3037 s->crypto_header.offset = cpu_to_be64(s->crypto_header.offset); in qcow2_update_header()
3038 s->crypto_header.length = cpu_to_be64(s->crypto_header.length); in qcow2_update_header()
3040 &s->crypto_header, sizeof(s->crypto_header), in qcow2_update_header()
3042 s->crypto_header.offset = be64_to_cpu(s->crypto_header.offset); in qcow2_update_header()
3043 s->crypto_header.length = be64_to_cpu(s->crypto_header.length); in qcow2_update_header()
3048 buflen -= ret; in qcow2_update_header()
3054 * 8-byte end-of-extension marker, that would leave only 8 bytes in qcow2_update_header()
3055 * for a backing file name in an image with 512-byte clusters. in qcow2_update_header()
3059 if (s->qcow_version >= 3 && s->cluster_size > 4096) { in qcow2_update_header()
3109 buflen -= ret; in qcow2_update_header()
3113 if (s->nb_bitmaps > 0) { in qcow2_update_header()
3115 .nb_bitmaps = cpu_to_be32(s->nb_bitmaps), in qcow2_update_header()
3117 cpu_to_be64(s->bitmap_directory_size), in qcow2_update_header()
3119 cpu_to_be64(s->bitmap_directory_offset) in qcow2_update_header()
3128 buflen -= ret; in qcow2_update_header()
3132 QLIST_FOREACH(uext, &s->unknown_header_ext, next) { in qcow2_update_header()
3133 ret = header_ext_add(buf, uext->magic, uext->data, uext->len, buflen); in qcow2_update_header()
3139 buflen -= ret; in qcow2_update_header()
3149 buflen -= ret; in qcow2_update_header()
3152 if (s->image_backing_file) { in qcow2_update_header()
3153 size_t backing_file_len = strlen(s->image_backing_file); in qcow2_update_header()
3156 ret = -ENOSPC; in qcow2_update_header()
3160 /* Using strncpy is ok here, since buf is not NUL-terminated. */ in qcow2_update_header()
3161 strncpy(buf, s->image_backing_file, buflen); in qcow2_update_header()
3163 header->backing_file_offset = cpu_to_be64(buf - ((char*) header)); in qcow2_update_header()
3164 header->backing_file_size = cpu_to_be32(backing_file_len); in qcow2_update_header()
3168 ret = bdrv_pwrite(bs->file, 0, s->cluster_size, header, 0); in qcow2_update_header()
3183 BDRVQcow2State *s = bs->opaque; in qcow2_co_change_backing_file()
3188 return -EINVAL; in qcow2_co_change_backing_file()
3192 return -EINVAL; in qcow2_co_change_backing_file()
3195 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), in qcow2_co_change_backing_file()
3197 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); in qcow2_co_change_backing_file()
3198 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); in qcow2_co_change_backing_file()
3200 g_free(s->image_backing_file); in qcow2_co_change_backing_file()
3201 g_free(s->image_backing_format); in qcow2_co_change_backing_file()
3203 s->image_backing_file = backing_file ? g_strdup(bs->backing_file) : NULL; in qcow2_co_change_backing_file()
3204 s->image_backing_format = backing_fmt ? g_strdup(bs->backing_format) : NULL; in qcow2_co_change_backing_file()
3214 BDRVQcow2State *s = bs->opaque; in qcow2_set_up_encryption()
3218 switch (cryptoopts->format) { in qcow2_set_up_encryption()
3225 default: in qcow2_set_up_encryption()
3227 return -EINVAL; in qcow2_set_up_encryption()
3230 s->crypt_method_header = fmt; in qcow2_set_up_encryption()
3237 return -EINVAL; in qcow2_set_up_encryption()
3242 error_setg_errno(errp, -ret, "Could not write encryption header"); in qcow2_set_up_encryption()
3257 * Returns: 0 on success, -errno on failure.
3261 PreallocMode mode, Error **errp) in preallocate_co() argument
3263 BDRVQcow2State *s = bs->opaque; in preallocate_co()
3272 bytes = new_length - offset; in preallocate_co()
3275 cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size)); in preallocate_co()
3279 error_setg_errno(errp, -ret, "Allocating clusters failed"); in preallocate_co()
3283 for (m = meta; m != NULL; m = m->next) { in preallocate_co()
3284 m->prealloc = true; in preallocate_co()
3289 error_setg_errno(errp, -ret, "Mapping clusters failed"); in preallocate_co()
3295 bytes -= cur_bytes; in preallocate_co()
3304 file_length = bdrv_co_getlength(s->data_file->bs); in preallocate_co()
3306 error_setg_errno(errp, -file_length, "Could not get file size"); in preallocate_co()
3312 if (mode == PREALLOC_MODE_METADATA) { in preallocate_co()
3313 mode = PREALLOC_MODE_OFF; in preallocate_co()
3315 ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false, in preallocate_co()
3316 mode, 0, errp); in preallocate_co()
3332 * @refcount_order: refcount bits power-of-2 exponent
3343 * Every host cluster is reference-counted, including metadata (even in qcow2_refcount_metadata_size()
3382 * @refcount_order: refcount bits power-of-2 exponent
3427 "%dk", 1 << MIN_CLUSTER_BITS, 1 << (MAX_CLUSTER_BITS - 10)); in validate_cluster_size()
3464 ret = 3; /* default */ in qcow2_opt_get_version_del()
3471 ret = -EINVAL; in qcow2_opt_get_version_del()
3509 * We keep things simple and start with a zero-sized image. We also in qcow2_co_create()
3514 * allocating two new refcount blocks - the second of which would be at in qcow2_co_create()
3529 assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2); in qcow2_co_create()
3530 qcow2_opts = &create_options->u.qcow2; in qcow2_co_create()
3532 bs = bdrv_co_open_blockdev_ref(qcow2_opts->file, errp); in qcow2_co_create()
3534 return -EIO; in qcow2_co_create()
3537 /* Validate options and set default values */ in qcow2_co_create()
3538 if (!QEMU_IS_ALIGNED(qcow2_opts->size, BDRV_SECTOR_SIZE)) { in qcow2_co_create()
3541 ret = -EINVAL; in qcow2_co_create()
3545 if (qcow2_opts->has_version) { in qcow2_co_create()
3546 switch (qcow2_opts->version) { in qcow2_co_create()
3553 default: in qcow2_co_create()
3560 if (qcow2_opts->has_cluster_size) { in qcow2_co_create()
3561 cluster_size = qcow2_opts->cluster_size; in qcow2_co_create()
3566 if (!qcow2_opts->has_extended_l2) { in qcow2_co_create()
3567 qcow2_opts->extended_l2 = false; in qcow2_co_create()
3569 if (qcow2_opts->extended_l2) { in qcow2_co_create()
3574 ret = -EINVAL; in qcow2_co_create()
3579 if (!validate_cluster_size(cluster_size, qcow2_opts->extended_l2, errp)) { in qcow2_co_create()
3580 ret = -EINVAL; in qcow2_co_create()
3584 if (!qcow2_opts->has_preallocation) { in qcow2_co_create()
3585 qcow2_opts->preallocation = PREALLOC_MODE_OFF; in qcow2_co_create()
3587 if (qcow2_opts->backing_file && in qcow2_co_create()
3588 qcow2_opts->preallocation != PREALLOC_MODE_OFF && in qcow2_co_create()
3589 !qcow2_opts->extended_l2) in qcow2_co_create()
3593 ret = -EINVAL; in qcow2_co_create()
3596 if (qcow2_opts->has_backing_fmt && !qcow2_opts->backing_file) { in qcow2_co_create()
3598 ret = -EINVAL; in qcow2_co_create()
3602 if (!qcow2_opts->has_lazy_refcounts) { in qcow2_co_create()
3603 qcow2_opts->lazy_refcounts = false; in qcow2_co_create()
3605 if (version < 3 && qcow2_opts->lazy_refcounts) { in qcow2_co_create()
3608 ret = -EINVAL; in qcow2_co_create()
3612 if (!qcow2_opts->has_refcount_bits) { in qcow2_co_create()
3613 qcow2_opts->refcount_bits = 16; in qcow2_co_create()
3615 if (qcow2_opts->refcount_bits > 64 || in qcow2_co_create()
3616 !is_power_of_2(qcow2_opts->refcount_bits)) in qcow2_co_create()
3620 ret = -EINVAL; in qcow2_co_create()
3623 if (version < 3 && qcow2_opts->refcount_bits != 16) { in qcow2_co_create()
3627 ret = -EINVAL; in qcow2_co_create()
3630 refcount_order = ctz32(qcow2_opts->refcount_bits); in qcow2_co_create()
3632 if (qcow2_opts->data_file_raw && !qcow2_opts->data_file) { in qcow2_co_create()
3633 error_setg(errp, "data-file-raw requires data-file"); in qcow2_co_create()
3634 ret = -EINVAL; in qcow2_co_create()
3637 if (qcow2_opts->data_file_raw && qcow2_opts->backing_file) { in qcow2_co_create()
3638 error_setg(errp, "Backing file and data-file-raw cannot be used at " in qcow2_co_create()
3640 ret = -EINVAL; in qcow2_co_create()
3643 if (qcow2_opts->data_file_raw && in qcow2_co_create()
3644 qcow2_opts->preallocation == PREALLOC_MODE_OFF) in qcow2_co_create()
3647 * data-file-raw means that "the external data file can be in qcow2_co_create()
3656 qcow2_opts->preallocation = PREALLOC_MODE_METADATA; in qcow2_co_create()
3663 assert(!qcow2_opts->backing_file); in qcow2_co_create()
3666 if (qcow2_opts->data_file) { in qcow2_co_create()
3671 ret = -EINVAL; in qcow2_co_create()
3674 data_bs = bdrv_co_open_blockdev_ref(qcow2_opts->data_file, errp); in qcow2_co_create()
3676 ret = -EIO; in qcow2_co_create()
3681 if (qcow2_opts->has_compression_type && in qcow2_co_create()
3682 qcow2_opts->compression_type != QCOW2_COMPRESSION_TYPE_ZLIB) { in qcow2_co_create()
3684 ret = -EINVAL; in qcow2_co_create()
3687 error_setg(errp, "Non-zlib compression type is only supported with " in qcow2_co_create()
3693 switch (qcow2_opts->compression_type) { in qcow2_co_create()
3698 default: in qcow2_co_create()
3703 compression_type = qcow2_opts->compression_type; in qcow2_co_create()
3710 ret = -EPERM; in qcow2_co_create()
3734 header->crypt_method = cpu_to_be32(QCOW_CRYPT_NONE); in qcow2_co_create()
3736 if (qcow2_opts->lazy_refcounts) { in qcow2_co_create()
3737 header->compatible_features |= in qcow2_co_create()
3741 header->incompatible_features |= in qcow2_co_create()
3744 if (qcow2_opts->data_file_raw) { in qcow2_co_create()
3745 header->autoclear_features |= in qcow2_co_create()
3749 header->incompatible_features |= in qcow2_co_create()
3753 if (qcow2_opts->extended_l2) { in qcow2_co_create()
3754 header->incompatible_features |= in qcow2_co_create()
3761 error_setg_errno(errp, -ret, "Could not write qcow2 header"); in qcow2_co_create()
3772 error_setg_errno(errp, -ret, "Could not write refcount table"); in qcow2_co_create()
3786 qdict_put_str(options, "file", bs->node_name); in qcow2_co_create()
3788 qdict_put_str(options, "data-file", data_bs->node_name); in qcow2_co_create()
3794 ret = -EIO; in qcow2_co_create()
3802 error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 " in qcow2_co_create()
3813 BDRVQcow2State *s = blk_bs(blk)->opaque; in qcow2_co_create()
3814 s->image_data_file = g_strdup(data_bs->filename); in qcow2_co_create()
3822 error_setg_errno(errp, -ret, "Could not update qcow2 header"); in qcow2_co_create()
3827 ret = blk_co_truncate(blk, qcow2_opts->size, false, in qcow2_co_create()
3828 qcow2_opts->preallocation, 0, errp); in qcow2_co_create()
3835 if (qcow2_opts->backing_file) { in qcow2_co_create()
3838 if (qcow2_opts->has_backing_fmt) { in qcow2_co_create()
3839 backing_format = BlockdevDriver_str(qcow2_opts->backing_fmt); in qcow2_co_create()
3843 ret = bdrv_co_change_backing_file(blk_bs(blk), qcow2_opts->backing_file, in qcow2_co_create()
3848 error_setg_errno(errp, -ret, "Could not assign backing file '%s' " in qcow2_co_create()
3849 "with format '%s'", qcow2_opts->backing_file, in qcow2_co_create()
3856 if (qcow2_opts->encrypt) { in qcow2_co_create()
3858 ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp); in qcow2_co_create()
3877 qdict_put_str(options, "file", bs->node_name); in qcow2_co_create()
3879 qdict_put_str(options, "data-file", data_bs->node_name); in qcow2_co_create()
3885 ret = -EIO; in qcow2_co_create()
3940 { BLOCK_OPT_BACKING_FILE, "backing-file" }, in qcow2_co_create_opts()
3941 { BLOCK_OPT_BACKING_FMT, "backing-fmt" }, in qcow2_co_create_opts()
3942 { BLOCK_OPT_CLUSTER_SIZE, "cluster-size" }, in qcow2_co_create_opts()
3943 { BLOCK_OPT_LAZY_REFCOUNTS, "lazy-refcounts" }, in qcow2_co_create_opts()
3944 { BLOCK_OPT_EXTL2, "extended-l2" }, in qcow2_co_create_opts()
3945 { BLOCK_OPT_REFCOUNT_BITS, "refcount-bits" }, in qcow2_co_create_opts()
3948 { BLOCK_OPT_DATA_FILE_RAW, "data-file-raw" }, in qcow2_co_create_opts()
3949 { BLOCK_OPT_COMPRESSION_TYPE, "compression-type" }, in qcow2_co_create_opts()
3954 ret = -EINVAL; in qcow2_co_create_opts()
3967 ret = -EIO; in qcow2_co_create_opts()
3983 ret = -EIO; in qcow2_co_create_opts()
3988 qdict_put_str(qdict, "data-file", data_bs->node_name); in qcow2_co_create_opts()
3993 qdict_put_str(qdict, "file", bs->node_name); in qcow2_co_create_opts()
3998 ret = -EINVAL; in qcow2_co_create_opts()
4005 ret = -EINVAL; in qcow2_co_create_opts()
4010 create_options->u.qcow2.size = ROUND_UP(create_options->u.qcow2.size, in qcow2_co_create_opts()
4040 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) { in is_zero()
4041 bytes = bs->total_sectors * BDRV_SECTOR_SIZE - offset; in is_zero()
4057 bytes -= nr; in is_zero()
4068 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwrite_zeroes()
4071 uint32_t tail = ROUND_UP(offset + bytes, s->subcluster_size) - in qcow2_co_pwrite_zeroes()
4075 if (offset + bytes == bs->total_sectors * BDRV_SECTOR_SIZE) { in qcow2_co_pwrite_zeroes()
4084 assert(head + bytes + tail <= s->subcluster_size); in qcow2_co_pwrite_zeroes()
4087 if (!(is_zero(bs, offset - head, head) && in qcow2_co_pwrite_zeroes()
4089 return -ENOTSUP; in qcow2_co_pwrite_zeroes()
4092 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwrite_zeroes()
4094 offset -= head; in qcow2_co_pwrite_zeroes()
4095 bytes = s->subcluster_size; in qcow2_co_pwrite_zeroes()
4096 nr = s->subcluster_size; in qcow2_co_pwrite_zeroes()
4103 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwrite_zeroes()
4104 return ret < 0 ? ret : -ENOTSUP; in qcow2_co_pwrite_zeroes()
4107 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwrite_zeroes()
4114 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwrite_zeroes()
4123 BDRVQcow2State *s = bs->opaque; in qcow2_co_pdiscard()
4127 if (s->qcow_version < 3 && bs->backing) { in qcow2_co_pdiscard()
4128 return -ENOTSUP; in qcow2_co_pdiscard()
4131 if (!QEMU_IS_ALIGNED(offset | bytes, s->cluster_size)) { in qcow2_co_pdiscard()
4132 assert(bytes < s->cluster_size); in qcow2_co_pdiscard()
4135 if (!QEMU_IS_ALIGNED(offset, s->cluster_size) || in qcow2_co_pdiscard()
4136 offset + bytes != bs->total_sectors * BDRV_SECTOR_SIZE) { in qcow2_co_pdiscard()
4137 return -ENOTSUP; in qcow2_co_pdiscard()
4141 qemu_co_mutex_lock(&s->lock); in qcow2_co_pdiscard()
4144 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pdiscard()
4155 BDRVQcow2State *s = bs->opaque; in qcow2_co_copy_range_from()
4161 assert(!bs->encrypted); in qcow2_co_copy_range_from()
4162 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_from()
4177 switch (type) { in qcow2_co_copy_range_from()
4180 if (bs->backing && bs->backing->bs) { in qcow2_co_copy_range_from()
4181 int64_t backing_length = bdrv_co_getlength(bs->backing->bs); in qcow2_co_copy_range_from()
4185 child = bs->backing; in qcow2_co_copy_range_from()
4186 cur_bytes = MIN(cur_bytes, backing_length - src_offset); in qcow2_co_copy_range_from()
4200 ret = -ENOTSUP; in qcow2_co_copy_range_from()
4204 child = s->data_file; in qcow2_co_copy_range_from()
4207 default: in qcow2_co_copy_range_from()
4210 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_from()
4215 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_from()
4220 bytes -= cur_bytes; in qcow2_co_copy_range_from()
4227 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_from()
4238 BDRVQcow2State *s = bs->opaque; in qcow2_co_copy_range_to()
4244 assert(!bs->encrypted); in qcow2_co_copy_range_to()
4246 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_to()
4255 * If src->bs == dst->bs, we could simply copy by incrementing in qcow2_co_copy_range_to()
4257 * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */ in qcow2_co_copy_range_to()
4270 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_to()
4271 ret = bdrv_co_copy_range_to(src, src_offset, s->data_file, host_offset, in qcow2_co_copy_range_to()
4273 qemu_co_mutex_lock(&s->lock); in qcow2_co_copy_range_to()
4283 bytes -= cur_bytes; in qcow2_co_copy_range_to()
4292 qemu_co_mutex_unlock(&s->lock); in qcow2_co_copy_range_to()
4304 BDRVQcow2State *s = bs->opaque; in qcow2_co_truncate()
4313 error_setg(errp, "Unsupported preallocation mode '%s'", in qcow2_co_truncate()
4315 return -ENOTSUP; in qcow2_co_truncate()
4321 return -EINVAL; in qcow2_co_truncate()
4324 qemu_co_mutex_lock(&s->lock); in qcow2_co_truncate()
4330 if (s->nb_snapshots && s->qcow_version < 3) { in qcow2_co_truncate()
4332 ret = -ENOTSUP; in qcow2_co_truncate()
4336 /* See qcow2-bitmap.c for which bitmap scenarios prevent a resize. */ in qcow2_co_truncate()
4338 ret = -ENOTSUP; in qcow2_co_truncate()
4342 old_length = bs->total_sectors * BDRV_SECTOR_SIZE; in qcow2_co_truncate()
4350 ret = -EINVAL; in qcow2_co_truncate()
4354 ret = qcow2_cluster_discard(bs, ROUND_UP(offset, s->cluster_size), in qcow2_co_truncate()
4355 old_length - ROUND_UP(offset, in qcow2_co_truncate()
4356 s->cluster_size), in qcow2_co_truncate()
4359 error_setg_errno(errp, -ret, "Failed to discard cropped clusters"); in qcow2_co_truncate()
4365 error_setg_errno(errp, -ret, in qcow2_co_truncate()
4372 error_setg_errno(errp, -ret, in qcow2_co_truncate()
4377 old_file_size = bdrv_co_getlength(bs->file->bs); in qcow2_co_truncate()
4379 error_setg_errno(errp, -old_file_size, in qcow2_co_truncate()
4386 error_setg_errno(errp, -last_cluster, in qcow2_co_truncate()
4391 if ((last_cluster + 1) * s->cluster_size < old_file_size) { in qcow2_co_truncate()
4397 * their qcow2 image (on a block device) with qemu-img. in qcow2_co_truncate()
4401 bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size, in qcow2_co_truncate()
4411 error_setg_errno(errp, -ret, "Failed to grow the L1 table"); in qcow2_co_truncate()
4417 * When creating a qcow2 image with data-file-raw, we enforce in qcow2_co_truncate()
4428 switch (prealloc) { in qcow2_co_truncate()
4436 ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0, in qcow2_co_truncate()
4470 old_file_size = bdrv_co_getlength(bs->file->bs); in qcow2_co_truncate()
4472 error_setg_errno(errp, -old_file_size, in qcow2_co_truncate()
4480 old_file_size = (last_cluster + 1) * s->cluster_size; in qcow2_co_truncate()
4482 old_file_size = ROUND_UP(old_file_size, s->cluster_size); in qcow2_co_truncate()
4485 nb_new_data_clusters = (ROUND_UP(offset, s->cluster_size) - in qcow2_co_truncate()
4486 start_of_cluster(s, old_length)) >> s->cluster_bits; in qcow2_co_truncate()
4499 s->cluster_size / l2_entry_size(s)); in qcow2_co_truncate()
4509 error_setg_errno(errp, -allocation_start, in qcow2_co_truncate()
4518 error_setg_errno(errp, -clusters_allocated, in qcow2_co_truncate()
4528 nb_new_data_clusters * s->cluster_size; in qcow2_co_truncate()
4536 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, in qcow2_co_truncate()
4544 ret = -1; in qcow2_co_truncate()
4547 ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0, in qcow2_co_truncate()
4553 nb_new_data_clusters * s->cluster_size, in qcow2_co_truncate()
4564 s->l2_slice_size - offset_to_l2_slice_index(s, guest_offset)); in qcow2_co_truncate()
4577 .offset = nb_clusters << s->cluster_bits, in qcow2_co_truncate()
4586 error_setg_errno(errp, -ret, "Failed to update L2 tables"); in qcow2_co_truncate()
4588 nb_new_data_clusters * s->cluster_size, in qcow2_co_truncate()
4593 guest_offset += nb_clusters * s->cluster_size; in qcow2_co_truncate()
4594 host_offset += nb_clusters * s->cluster_size; in qcow2_co_truncate()
4595 nb_new_data_clusters -= nb_clusters; in qcow2_co_truncate()
4600 default: in qcow2_co_truncate()
4605 uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->subcluster_size); in qcow2_co_truncate()
4609 * requires a subcluster-aligned start. The end may be unaligned if in qcow2_co_truncate()
4613 ret = qcow2_subcluster_zeroize(bs, zero_start, offset - zero_start, in qcow2_co_truncate()
4616 error_setg_errno(errp, -ret, "Failed to zero out new clusters"); in qcow2_co_truncate()
4623 uint64_t len = MIN(zero_start, offset) - old_length; in qcow2_co_truncate()
4628 qemu_co_mutex_unlock(&s->lock); in qcow2_co_truncate()
4630 qemu_co_mutex_lock(&s->lock); in qcow2_co_truncate()
4634 error_setg_errno(errp, -ret, "Failed to zero out the new area"); in qcow2_co_truncate()
4644 error_setg_errno(errp, -ret, in qcow2_co_truncate()
4650 bs->total_sectors = offset / BDRV_SECTOR_SIZE; in qcow2_co_truncate()
4654 ret = bdrv_co_pwrite_sync(bs->file, offsetof(QCowHeader, size), in qcow2_co_truncate()
4657 error_setg_errno(errp, -ret, "Failed to update the image size"); in qcow2_co_truncate()
4661 s->l1_vm_state_index = new_l1_size; in qcow2_co_truncate()
4664 options = qdict_clone_shallow(bs->options); in qcow2_co_truncate()
4665 ret = qcow2_update_options(bs, options, s->flags, errp); in qcow2_co_truncate()
4672 qemu_co_mutex_unlock(&s->lock); in qcow2_co_truncate()
4681 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwritev_compressed_task()
4687 assert(bytes == s->cluster_size || (bytes < s->cluster_size && in qcow2_co_pwritev_compressed_task()
4688 (offset + bytes == bs->total_sectors << BDRV_SECTOR_BITS))); in qcow2_co_pwritev_compressed_task()
4690 buf = qemu_blockalign(bs, s->cluster_size); in qcow2_co_pwritev_compressed_task()
4691 if (bytes < s->cluster_size) { in qcow2_co_pwritev_compressed_task()
4692 /* Zero-pad last write if image size is not cluster aligned */ in qcow2_co_pwritev_compressed_task()
4693 memset(buf + bytes, 0, s->cluster_size - bytes); in qcow2_co_pwritev_compressed_task()
4697 out_buf = g_malloc(s->cluster_size); in qcow2_co_pwritev_compressed_task()
4699 out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1, in qcow2_co_pwritev_compressed_task()
4700 buf, s->cluster_size); in qcow2_co_pwritev_compressed_task()
4701 if (out_len == -ENOMEM) { in qcow2_co_pwritev_compressed_task()
4709 ret = -EINVAL; in qcow2_co_pwritev_compressed_task()
4713 qemu_co_mutex_lock(&s->lock); in qcow2_co_pwritev_compressed_task()
4717 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwritev_compressed_task()
4722 qemu_co_mutex_unlock(&s->lock); in qcow2_co_pwritev_compressed_task()
4727 BLKDBG_CO_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED); in qcow2_co_pwritev_compressed_task()
4728 ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0); in qcow2_co_pwritev_compressed_task()
4750 assert(!t->subcluster_type && !t->l2meta); in qcow2_co_pwritev_compressed_task_entry()
4752 return qcow2_co_pwritev_compressed_task(t->bs, t->offset, t->bytes, t->qiov, in qcow2_co_pwritev_compressed_task_entry()
4753 t->qiov_offset); in qcow2_co_pwritev_compressed_task_entry()
4765 BDRVQcow2State *s = bs->opaque; in qcow2_co_pwritev_compressed_part()
4770 return -ENOTSUP; in qcow2_co_pwritev_compressed_part()
4778 int64_t len = bdrv_co_getlength(bs->file->bs); in qcow2_co_pwritev_compressed_part()
4782 return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0, in qcow2_co_pwritev_compressed_part()
4787 return -EINVAL; in qcow2_co_pwritev_compressed_part()
4791 (offset + bytes) != (bs->total_sectors << BDRV_SECTOR_BITS)) { in qcow2_co_pwritev_compressed_part()
4792 return -EINVAL; in qcow2_co_pwritev_compressed_part()
4796 uint64_t chunk_size = MIN(bytes, s->cluster_size); in qcow2_co_pwritev_compressed_part()
4809 bytes -= chunk_size; in qcow2_co_pwritev_compressed_part()
4831 BDRVQcow2State *s = bs->opaque; in qcow2_co_preadv_compressed()
4841 return -ENOMEM; in qcow2_co_preadv_compressed()
4844 out_buf = qemu_blockalign(bs, s->cluster_size); in qcow2_co_preadv_compressed()
4846 BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_COMPRESSED); in qcow2_co_preadv_compressed()
4847 ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0); in qcow2_co_preadv_compressed()
4852 if (qcow2_co_decompress(bs, out_buf, s->cluster_size, buf, csize) < 0) { in qcow2_co_preadv_compressed()
4853 ret = -EIO; in qcow2_co_preadv_compressed()
4868 BDRVQcow2State *s = bs->opaque; in make_completely_empty()
4880 ret = qcow2_cache_empty(bs, s->l2_table_cache); in make_completely_empty()
4885 ret = qcow2_cache_empty(bs, s->refcount_block_cache); in make_completely_empty()
4896 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); in make_completely_empty()
4898 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE); in make_completely_empty()
4899 l1_size2 = (uint64_t)s->l1_size * L1E_SIZE; in make_completely_empty()
4901 /* After this call, neither the in-memory nor the on-disk refcount in make_completely_empty()
4904 ret = bdrv_pwrite_zeroes(bs->file, s->l1_table_offset, in make_completely_empty()
4905 l1_clusters * s->cluster_size, 0); in make_completely_empty()
4909 memset(s->l1_table, 0, l1_size2); in make_completely_empty()
4911 BLKDBG_EVENT(bs->file, BLKDBG_EMPTY_IMAGE_PREPARE); in make_completely_empty()
4918 ret = bdrv_pwrite_zeroes(bs->file, s->cluster_size, in make_completely_empty()
4919 (2 + l1_clusters) * s->cluster_size, 0); in make_completely_empty()
4920 /* This call (even if it failed overall) may have overwritten on-disk in make_completely_empty()
4921 * refcount structures; in that case, the in-memory refcount information in make_completely_empty()
4922 * will probably differ from the on-disk information which makes the BDS in make_completely_empty()
4928 BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE); in make_completely_empty()
4929 BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_UPDATE); in make_completely_empty()
4934 l1_ofs_rt_ofs_cls.l1_offset = cpu_to_be64(3 * s->cluster_size); in make_completely_empty()
4935 l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size); in make_completely_empty()
4937 ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset), in make_completely_empty()
4943 s->l1_table_offset = 3 * s->cluster_size; in make_completely_empty()
4945 new_reftable = g_try_new0(uint64_t, s->cluster_size / REFTABLE_ENTRY_SIZE); in make_completely_empty()
4947 ret = -ENOMEM; in make_completely_empty()
4951 s->refcount_table_offset = s->cluster_size; in make_completely_empty()
4952 s->refcount_table_size = s->cluster_size / REFTABLE_ENTRY_SIZE; in make_completely_empty()
4953 s->max_refcount_table_index = 0; in make_completely_empty()
4955 g_free(s->refcount_table); in make_completely_empty()
4956 s->refcount_table = new_reftable; in make_completely_empty()
4959 /* Now the in-memory refcount information again corresponds to the on-disk in make_completely_empty()
4963 * the in-memory information is always correct */ in make_completely_empty()
4965 BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); in make_completely_empty()
4968 rt_entry = cpu_to_be64(2 * s->cluster_size); in make_completely_empty()
4969 ret = bdrv_pwrite_sync(bs->file, s->cluster_size, sizeof(rt_entry), in make_completely_empty()
4974 s->refcount_table[0] = 2 * s->cluster_size; in make_completely_empty()
4976 s->free_cluster_index = 0; in make_completely_empty()
4977 assert(3 + l1_clusters <= s->refcount_block_size); in make_completely_empty()
4978 offset = qcow2_alloc_clusters(bs, 3 * s->cluster_size + l1_size2); in make_completely_empty()
4987 /* Now finally the in-memory information corresponds to the on-disk in make_completely_empty()
4994 ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false, in make_completely_empty()
5010 bs->drv = NULL; in make_completely_empty()
5019 BDRVQcow2State *s = bs->opaque; in qcow2_make_empty()
5021 int step = QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size); in qcow2_make_empty()
5024 l1_clusters = DIV_ROUND_UP(s->l1_size, s->cluster_size / L1E_SIZE); in qcow2_make_empty()
5026 if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps && in qcow2_make_empty()
5027 3 + l1_clusters <= s->refcount_block_size && in qcow2_make_empty()
5028 s->crypt_method_header != QCOW_CRYPT_LUKS && in qcow2_make_empty()
5044 end_offset = bs->total_sectors * BDRV_SECTOR_SIZE; in qcow2_make_empty()
5048 * default action for this kind of discard is to pass the discard, in qcow2_make_empty()
5051 ret = qcow2_cluster_discard(bs, offset, MIN(step, end_offset - offset), in qcow2_make_empty()
5063 BDRVQcow2State *s = bs->opaque; in qcow2_co_flush_to_os()
5066 qemu_co_mutex_lock(&s->lock); in qcow2_co_flush_to_os()
5068 qemu_co_mutex_unlock(&s->lock); in qcow2_co_flush_to_os()
5165 error_setg_errno(&local_err, -ssize, in qcow2_measure()
5187 ssize - offset, &pnum, NULL, in qcow2_measure()
5190 error_setg_errno(&local_err, -ret, in qcow2_measure()
5200 pnum = ROUND_UP(offset + pnum, cluster_size) - offset; in qcow2_measure()
5217 info->fully_allocated = luks_payload_size + in qcow2_measure()
5227 info->required = info->fully_allocated - virtual_size + required; in qcow2_measure()
5228 info->has_bitmaps = version >= 3 && in_bs && in qcow2_measure()
5230 if (info->has_bitmaps) { in qcow2_measure()
5231 info->bitmaps = qcow2_get_persistent_dirty_bitmap_size(in_bs, in qcow2_measure()
5244 BDRVQcow2State *s = bs->opaque; in qcow2_co_get_info()
5245 bdi->cluster_size = s->cluster_size; in qcow2_co_get_info()
5246 bdi->subcluster_size = s->subcluster_size; in qcow2_co_get_info()
5247 bdi->vm_state_offset = qcow2_vm_state_offset(s); in qcow2_co_get_info()
5248 bdi->is_dirty = s->incompatible_features & QCOW2_INCOMPAT_DIRTY; in qcow2_co_get_info()
5255 BDRVQcow2State *s = bs->opaque; in qcow2_get_specific_info()
5259 if (s->crypto != NULL) { in qcow2_get_specific_info()
5260 encrypt_info = qcrypto_block_get_info(s->crypto, errp); in qcow2_get_specific_info()
5271 if (s->qcow_version == 2) { in qcow2_get_specific_info()
5272 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ in qcow2_get_specific_info()
5274 .refcount_bits = s->refcount_bits, in qcow2_get_specific_info()
5276 } else if (s->qcow_version == 3) { in qcow2_get_specific_info()
5283 *spec_info->u.qcow2.data = (ImageInfoSpecificQCow2){ in qcow2_get_specific_info()
5285 .lazy_refcounts = s->compatible_features & in qcow2_get_specific_info()
5288 .corrupt = s->incompatible_features & in qcow2_get_specific_info()
5293 .refcount_bits = s->refcount_bits, in qcow2_get_specific_info()
5296 .data_file = g_strdup(s->image_data_file), in qcow2_get_specific_info()
5299 .compression_type = s->compression_type, in qcow2_get_specific_info()
5310 switch (encrypt_info->format) { in qcow2_get_specific_info()
5312 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES; in qcow2_get_specific_info()
5315 qencrypt->format = BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS; in qcow2_get_specific_info()
5316 qencrypt->u.luks = encrypt_info->u.luks; in qcow2_get_specific_info()
5318 default: in qcow2_get_specific_info()
5323 memset(&encrypt_info->u, 0, sizeof(encrypt_info->u)); in qcow2_get_specific_info()
5326 spec_info->u.qcow2.data->encrypt = qencrypt; in qcow2_get_specific_info()
5335 BDRVQcow2State *s = bs->opaque; in qcow2_has_zero_init()
5339 qemu_co_mutex_lock(&s->lock); in qcow2_has_zero_init()
5346 preallocated = s->l1_size > 0 && s->l1_table[0] != 0; in qcow2_has_zero_init()
5348 qemu_co_mutex_unlock(&s->lock); in qcow2_has_zero_init()
5353 } else if (bs->encrypted) { in qcow2_has_zero_init()
5356 return bdrv_has_zero_init(s->data_file->bs); in qcow2_has_zero_init()
5367 BDRVQcow2State *s = bs->opaque; in qcow2_check_vmstate_request()
5372 bdrv_check_qiov_request(pos, qiov->size, qiov, 0, &error_abort); in qcow2_check_vmstate_request()
5374 if (INT64_MAX - pos < vmstate_offset) { in qcow2_check_vmstate_request()
5375 return -EIO; in qcow2_check_vmstate_request()
5379 ret = bdrv_check_qiov_request(pos, qiov->size, qiov, 0, NULL); in qcow2_check_vmstate_request()
5395 BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); in qcow2_co_save_vmstate()
5396 return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0); in qcow2_co_save_vmstate()
5407 BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); in qcow2_co_load_vmstate()
5408 return bs->drv->bdrv_co_preadv_part(bs, offset, qiov->size, qiov, 0, 0); in qcow2_co_load_vmstate()
5437 bytes -= cur_bytes; in qcow2_has_compressed_clusters()
5452 BDRVQcow2State *s = bs->opaque; in qcow2_downgrade()
5453 int current_version = s->qcow_version; in qcow2_downgrade()
5463 if (s->refcount_order != 4) { in qcow2_downgrade()
5465 return -ENOTSUP; in qcow2_downgrade()
5470 return -ENOTSUP; in qcow2_downgrade()
5476 * is unsafe. Even though we would still use v3-compliant output in qcow2_downgrade()
5480 for (i = 0; i < s->nb_snapshots; i++) { in qcow2_downgrade()
5481 if (s->snapshots[i].vm_state_size > UINT32_MAX || in qcow2_downgrade()
5482 s->snapshots[i].disk_size != bs->total_sectors * BDRV_SECTOR_SIZE) { in qcow2_downgrade()
5484 return -ENOTSUP; in qcow2_downgrade()
5489 if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { in qcow2_downgrade()
5492 error_setg_errno(errp, -ret, "Failed to make the image clean"); in qcow2_downgrade()
5498 * the first place; if that happens nonetheless, returning -ENOTSUP is the in qcow2_downgrade()
5501 if (s->incompatible_features & ~QCOW2_INCOMPAT_COMPRESSION) { in qcow2_downgrade()
5504 s->incompatible_features & ~QCOW2_INCOMPAT_COMPRESSION); in qcow2_downgrade()
5505 return -ENOTSUP; in qcow2_downgrade()
5509 s->compatible_features = 0; in qcow2_downgrade()
5514 s->autoclear_features = 0; in qcow2_downgrade()
5518 error_setg_errno(errp, -ret, "Failed to turn zero into data clusters"); in qcow2_downgrade()
5522 if (s->incompatible_features & QCOW2_INCOMPAT_COMPRESSION) { in qcow2_downgrade()
5526 return -EINVAL; in qcow2_downgrade()
5531 return -ENOTSUP; in qcow2_downgrade()
5534 * No compressed clusters for now, so just chose default zlib in qcow2_downgrade()
5537 s->incompatible_features &= ~QCOW2_INCOMPAT_COMPRESSION; in qcow2_downgrade()
5538 s->compression_type = QCOW2_COMPRESSION_TYPE_ZLIB; in qcow2_downgrade()
5541 assert(s->incompatible_features == 0); in qcow2_downgrade()
5543 s->qcow_version = target_version; in qcow2_downgrade()
5546 s->qcow_version = current_version; in qcow2_downgrade()
5547 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_downgrade()
5563 BDRVQcow2State *s = bs->opaque; in qcow2_upgrade()
5565 int current_version = s->qcow_version; in qcow2_upgrade()
5579 * the 64-bit VM state size and the virtual disk size to be in qcow2_upgrade()
5582 * v3-compliant format. in qcow2_upgrade()
5585 for (i = 0; i < s->nb_snapshots; i++) { in qcow2_upgrade()
5586 if (s->snapshots[i].extra_data_size < in qcow2_upgrade()
5597 error_setg_errno(errp, -ret, "Failed to update the snapshot table"); in qcow2_upgrade()
5603 s->qcow_version = target_version; in qcow2_upgrade()
5606 s->qcow_version = current_version; in qcow2_upgrade()
5607 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_upgrade()
5658 if (info->current_operation != info->last_operation) { in qcow2_amend_helper_cb()
5659 if (info->last_operation != QCOW2_NO_OPERATION) { in qcow2_amend_helper_cb()
5660 info->offset_completed += info->last_work_size; in qcow2_amend_helper_cb()
5661 info->operations_completed++; in qcow2_amend_helper_cb()
5664 info->last_operation = info->current_operation; in qcow2_amend_helper_cb()
5667 assert(info->total_operations > 0); in qcow2_amend_helper_cb()
5668 assert(info->operations_completed < info->total_operations); in qcow2_amend_helper_cb()
5670 info->last_work_size = operation_work_size; in qcow2_amend_helper_cb()
5672 current_work_size = info->offset_completed + operation_work_size; in qcow2_amend_helper_cb()
5678 projected_work_size = current_work_size * (info->total_operations - in qcow2_amend_helper_cb()
5679 info->operations_completed - 1) in qcow2_amend_helper_cb()
5680 / (info->operations_completed + 1); in qcow2_amend_helper_cb()
5682 info->original_status_cb(bs, info->offset_completed + operation_offset, in qcow2_amend_helper_cb()
5684 info->original_cb_opaque); in qcow2_amend_helper_cb()
5692 BDRVQcow2State *s = bs->opaque; in qcow2_amend_options()
5693 int old_version = s->qcow_version, new_version = old_version; in qcow2_amend_options()
5696 bool lazy_refcounts = s->use_lazy_refcounts; in qcow2_amend_options()
5699 int refcount_bits = s->refcount_bits; in qcow2_amend_options()
5701 QemuOptDesc *desc = opts->list->desc; in qcow2_amend_options()
5705 while (desc && desc->name) { in qcow2_amend_options()
5706 if (!qemu_opt_find(opts, desc->name)) { in qcow2_amend_options()
5712 if (!strcmp(desc->name, BLOCK_OPT_COMPAT_LEVEL)) { in qcow2_amend_options()
5715 /* preserve default */ in qcow2_amend_options()
5722 return -EINVAL; in qcow2_amend_options()
5724 } else if (!strcmp(desc->name, BLOCK_OPT_SIZE)) { in qcow2_amend_options()
5726 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FILE)) { in qcow2_amend_options()
5728 } else if (!strcmp(desc->name, BLOCK_OPT_BACKING_FMT)) { in qcow2_amend_options()
5730 } else if (g_str_has_prefix(desc->name, "encrypt.")) { in qcow2_amend_options()
5731 if (!s->crypto) { in qcow2_amend_options()
5733 "Can't amend encryption options - encryption not present"); in qcow2_amend_options()
5734 return -EINVAL; in qcow2_amend_options()
5736 if (s->crypt_method_header != QCOW_CRYPT_LUKS) { in qcow2_amend_options()
5739 return -ENOTSUP; in qcow2_amend_options()
5742 } else if (!strcmp(desc->name, BLOCK_OPT_LAZY_REFCOUNTS)) { in qcow2_amend_options()
5745 } else if (!strcmp(desc->name, BLOCK_OPT_REFCOUNT_BITS)) { in qcow2_amend_options()
5754 return -EINVAL; in qcow2_amend_options()
5756 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE)) { in qcow2_amend_options()
5759 error_setg(errp, "data-file can only be set for images that " in qcow2_amend_options()
5761 return -EINVAL; in qcow2_amend_options()
5763 } else if (!strcmp(desc->name, BLOCK_OPT_DATA_FILE_RAW)) { in qcow2_amend_options()
5767 error_setg(errp, "data-file-raw cannot be set on existing " in qcow2_amend_options()
5769 return -EINVAL; in qcow2_amend_options()
5784 + (s->refcount_bits != refcount_bits) + in qcow2_amend_options()
5805 return -EINVAL; in qcow2_amend_options()
5810 return -EINVAL; in qcow2_amend_options()
5812 ret = qcrypto_block_amend_options(s->crypto, in qcow2_amend_options()
5825 if (s->refcount_bits != refcount_bits) { in qcow2_amend_options()
5832 return -EINVAL; in qcow2_amend_options()
5844 /* data-file-raw blocks backing files, so clear it first if requested */ in qcow2_amend_options()
5846 s->autoclear_features |= QCOW2_AUTOCLEAR_DATA_FILE_RAW; in qcow2_amend_options()
5848 s->autoclear_features &= ~QCOW2_AUTOCLEAR_DATA_FILE_RAW; in qcow2_amend_options()
5852 g_free(s->image_data_file); in qcow2_amend_options()
5853 s->image_data_file = *data_file ? g_strdup(data_file) : NULL; in qcow2_amend_options()
5858 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_amend_options()
5863 if (g_strcmp0(backing_file, s->image_backing_file) || in qcow2_amend_options()
5864 g_strcmp0(backing_format, s->image_backing_format)) { in qcow2_amend_options()
5867 "You can use 'qemu-img rebase' instead.\n"); in qcow2_amend_options()
5868 return -EINVAL; in qcow2_amend_options()
5872 if (s->use_lazy_refcounts != lazy_refcounts) { in qcow2_amend_options()
5878 return -EINVAL; in qcow2_amend_options()
5880 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5883 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5884 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_amend_options()
5887 s->use_lazy_refcounts = true; in qcow2_amend_options()
5892 error_setg_errno(errp, -ret, "Failed to make the image clean"); in qcow2_amend_options()
5896 s->compatible_features &= ~QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5899 s->compatible_features |= QCOW2_COMPAT_LAZY_REFCOUNTS; in qcow2_amend_options()
5900 error_setg_errno(errp, -ret, "Failed to update the image header"); in qcow2_amend_options()
5903 s->use_lazy_refcounts = false; in qcow2_amend_options()
5911 return -EPERM; in qcow2_amend_options()
5943 BlockdevAmendOptionsQcow2 *qopts = &opts->u.qcow2; in qcow2_co_amend()
5944 BDRVQcow2State *s = bs->opaque; in qcow2_co_amend()
5947 if (qopts->encrypt) { in qcow2_co_amend()
5948 if (!s->crypto) { in qcow2_co_amend()
5950 return -EOPNOTSUPP; in qcow2_co_amend()
5953 if (qopts->encrypt->format != QCRYPTO_BLOCK_FORMAT_LUKS) { in qcow2_co_amend()
5956 return -EOPNOTSUPP; in qcow2_co_amend()
5959 if (s->crypt_method_header != QCOW_CRYPT_LUKS) { in qcow2_co_amend()
5961 "Only LUKS encryption options can be amended for qcow2 with blockdev-amend"); in qcow2_co_amend()
5962 return -EOPNOTSUPP; in qcow2_co_amend()
5965 ret = qcrypto_block_amend_options(s->crypto, in qcow2_co_amend()
5969 qopts->encrypt, in qcow2_co_amend()
5979 * fatal will be ignored for read-only BDS; corruptions found there will always
5980 * be considered non-fatal.
5985 BDRVQcow2State *s = bs->opaque; in qcow2_signal_corruption()
5992 if (s->signaled_corruption && in qcow2_signal_corruption()
5993 (!fatal || (s->incompatible_features & QCOW2_INCOMPAT_CORRUPT))) in qcow2_signal_corruption()
6006 fprintf(stderr, "qcow2: Image is corrupt: %s; further non-fatal " in qcow2_signal_corruption()
6020 bs->drv = NULL; /* make BDS unusable */ in qcow2_signal_corruption()
6023 s->signaled_corruption = true; in qcow2_signal_corruption()
6072 .name = "qcow2-create-opts",
6109 .help = "Preallocation mode (allowed values: off, " \
6125 .name = "qcow2-amend-opts",