xlnx-zynqmp-rtc: Initial commit
[qemu/ar7.git] / block / qcow2-bitmap.c
blob4f6fd863eabb1fa42e8ea1b9c9050162eda1522b
1 /*
2 * Bitmaps for the QCOW version 2 format
4 * Copyright (c) 2014-2017 Vladimir Sementsov-Ogievskiy
6 * This file is derived from qcow2-snapshot.c, original copyright:
7 * Copyright (c) 2004-2006 Fabrice Bellard
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 * THE SOFTWARE.
28 #include "qemu/osdep.h"
29 #include "qapi/error.h"
30 #include "qemu/cutils.h"
32 #include "block/block_int.h"
33 #include "block/qcow2.h"
35 /* NOTICE: BME here means Bitmaps Extension and used as a namespace for
36 * _internal_ constants. Please do not use this _internal_ abbreviation for
37 * other needs and/or outside of this file. */
39 /* Bitmap directory entry constraints */
40 #define BME_MAX_TABLE_SIZE 0x8000000
41 #define BME_MAX_PHYS_SIZE 0x20000000 /* restrict BdrvDirtyBitmap size in RAM */
42 #define BME_MAX_GRANULARITY_BITS 31
43 #define BME_MIN_GRANULARITY_BITS 9
44 #define BME_MAX_NAME_SIZE 1023
46 #if BME_MAX_TABLE_SIZE * 8ULL > INT_MAX
47 #error In the code bitmap table physical size assumed to fit into int
48 #endif
50 /* Bitmap directory entry flags */
51 #define BME_RESERVED_FLAGS 0xfffffffcU
52 #define BME_FLAG_IN_USE (1U << 0)
53 #define BME_FLAG_AUTO (1U << 1)
55 /* bits [1, 8] U [56, 63] are reserved */
56 #define BME_TABLE_ENTRY_RESERVED_MASK 0xff000000000001feULL
57 #define BME_TABLE_ENTRY_OFFSET_MASK 0x00fffffffffffe00ULL
58 #define BME_TABLE_ENTRY_FLAG_ALL_ONES (1ULL << 0)
60 typedef struct QEMU_PACKED Qcow2BitmapDirEntry {
61 /* header is 8 byte aligned */
62 uint64_t bitmap_table_offset;
64 uint32_t bitmap_table_size;
65 uint32_t flags;
67 uint8_t type;
68 uint8_t granularity_bits;
69 uint16_t name_size;
70 uint32_t extra_data_size;
71 /* extra data follows */
72 /* name follows */
73 } Qcow2BitmapDirEntry;
75 typedef struct Qcow2BitmapTable {
76 uint64_t offset;
77 uint32_t size; /* number of 64bit entries */
78 QSIMPLEQ_ENTRY(Qcow2BitmapTable) entry;
79 } Qcow2BitmapTable;
80 typedef QSIMPLEQ_HEAD(Qcow2BitmapTableList, Qcow2BitmapTable)
81 Qcow2BitmapTableList;
83 typedef struct Qcow2Bitmap {
84 Qcow2BitmapTable table;
85 uint32_t flags;
86 uint8_t granularity_bits;
87 char *name;
89 BdrvDirtyBitmap *dirty_bitmap;
91 QSIMPLEQ_ENTRY(Qcow2Bitmap) entry;
92 } Qcow2Bitmap;
93 typedef QSIMPLEQ_HEAD(Qcow2BitmapList, Qcow2Bitmap) Qcow2BitmapList;
95 typedef enum BitmapType {
96 BT_DIRTY_TRACKING_BITMAP = 1
97 } BitmapType;
99 static inline bool can_write(BlockDriverState *bs)
101 return !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
104 static int update_header_sync(BlockDriverState *bs)
106 int ret;
108 ret = qcow2_update_header(bs);
109 if (ret < 0) {
110 return ret;
113 return bdrv_flush(bs);
116 static inline void bitmap_table_to_be(uint64_t *bitmap_table, size_t size)
118 size_t i;
120 for (i = 0; i < size; ++i) {
121 cpu_to_be64s(&bitmap_table[i]);
125 static int check_table_entry(uint64_t entry, int cluster_size)
127 uint64_t offset;
129 if (entry & BME_TABLE_ENTRY_RESERVED_MASK) {
130 return -EINVAL;
133 offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
134 if (offset != 0) {
135 /* if offset specified, bit 0 is reserved */
136 if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) {
137 return -EINVAL;
140 if (offset % cluster_size != 0) {
141 return -EINVAL;
145 return 0;
148 static int check_constraints_on_bitmap(BlockDriverState *bs,
149 const char *name,
150 uint32_t granularity,
151 Error **errp)
153 BDRVQcow2State *s = bs->opaque;
154 int granularity_bits = ctz32(granularity);
155 int64_t len = bdrv_getlength(bs);
157 assert(granularity > 0);
158 assert((granularity & (granularity - 1)) == 0);
160 if (len < 0) {
161 error_setg_errno(errp, -len, "Failed to get size of '%s'",
162 bdrv_get_device_or_node_name(bs));
163 return len;
166 if (granularity_bits > BME_MAX_GRANULARITY_BITS) {
167 error_setg(errp, "Granularity exceeds maximum (%llu bytes)",
168 1ULL << BME_MAX_GRANULARITY_BITS);
169 return -EINVAL;
171 if (granularity_bits < BME_MIN_GRANULARITY_BITS) {
172 error_setg(errp, "Granularity is under minimum (%llu bytes)",
173 1ULL << BME_MIN_GRANULARITY_BITS);
174 return -EINVAL;
177 if ((len > (uint64_t)BME_MAX_PHYS_SIZE << granularity_bits) ||
178 (len > (uint64_t)BME_MAX_TABLE_SIZE * s->cluster_size <<
179 granularity_bits))
181 error_setg(errp, "Too much space will be occupied by the bitmap. "
182 "Use larger granularity");
183 return -EINVAL;
186 if (strlen(name) > BME_MAX_NAME_SIZE) {
187 error_setg(errp, "Name length exceeds maximum (%u characters)",
188 BME_MAX_NAME_SIZE);
189 return -EINVAL;
192 return 0;
195 static void clear_bitmap_table(BlockDriverState *bs, uint64_t *bitmap_table,
196 uint32_t bitmap_table_size)
198 BDRVQcow2State *s = bs->opaque;
199 int i;
201 for (i = 0; i < bitmap_table_size; ++i) {
202 uint64_t addr = bitmap_table[i] & BME_TABLE_ENTRY_OFFSET_MASK;
203 if (!addr) {
204 continue;
207 qcow2_free_clusters(bs, addr, s->cluster_size, QCOW2_DISCARD_OTHER);
208 bitmap_table[i] = 0;
212 static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
213 uint64_t **bitmap_table)
215 int ret;
216 BDRVQcow2State *s = bs->opaque;
217 uint32_t i;
218 uint64_t *table;
220 assert(tb->size != 0);
221 table = g_try_new(uint64_t, tb->size);
222 if (table == NULL) {
223 return -ENOMEM;
226 assert(tb->size <= BME_MAX_TABLE_SIZE);
227 ret = bdrv_pread(bs->file, tb->offset,
228 table, tb->size * sizeof(uint64_t));
229 if (ret < 0) {
230 goto fail;
233 for (i = 0; i < tb->size; ++i) {
234 be64_to_cpus(&table[i]);
235 ret = check_table_entry(table[i], s->cluster_size);
236 if (ret < 0) {
237 goto fail;
241 *bitmap_table = table;
242 return 0;
244 fail:
245 g_free(table);
247 return ret;
250 static int free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb)
252 int ret;
253 uint64_t *bitmap_table;
255 ret = bitmap_table_load(bs, tb, &bitmap_table);
256 if (ret < 0) {
257 assert(bitmap_table == NULL);
258 return ret;
261 clear_bitmap_table(bs, bitmap_table, tb->size);
262 qcow2_free_clusters(bs, tb->offset, tb->size * sizeof(uint64_t),
263 QCOW2_DISCARD_OTHER);
264 g_free(bitmap_table);
266 tb->offset = 0;
267 tb->size = 0;
269 return 0;
272 /* Return the disk size covered by a single qcow2 cluster of bitmap data. */
273 static uint64_t bytes_covered_by_bitmap_cluster(const BDRVQcow2State *s,
274 const BdrvDirtyBitmap *bitmap)
276 uint64_t granularity = bdrv_dirty_bitmap_granularity(bitmap);
277 uint64_t limit = granularity * (s->cluster_size << 3);
279 assert(QEMU_IS_ALIGNED(limit,
280 bdrv_dirty_bitmap_serialization_align(bitmap)));
281 return limit;
284 /* load_bitmap_data
285 * @bitmap_table entries must satisfy specification constraints.
286 * @bitmap must be cleared */
287 static int load_bitmap_data(BlockDriverState *bs,
288 const uint64_t *bitmap_table,
289 uint32_t bitmap_table_size,
290 BdrvDirtyBitmap *bitmap)
292 int ret = 0;
293 BDRVQcow2State *s = bs->opaque;
294 uint64_t offset, limit;
295 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
296 uint8_t *buf = NULL;
297 uint64_t i, tab_size =
298 size_to_clusters(s,
299 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
301 if (tab_size != bitmap_table_size || tab_size > BME_MAX_TABLE_SIZE) {
302 return -EINVAL;
305 buf = g_malloc(s->cluster_size);
306 limit = bytes_covered_by_bitmap_cluster(s, bitmap);
307 for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) {
308 uint64_t count = MIN(bm_size - offset, limit);
309 uint64_t entry = bitmap_table[i];
310 uint64_t data_offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
312 assert(check_table_entry(entry, s->cluster_size) == 0);
314 if (data_offset == 0) {
315 if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) {
316 bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count,
317 false);
318 } else {
319 /* No need to deserialize zeros because the dirty bitmap is
320 * already cleared */
322 } else {
323 ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size);
324 if (ret < 0) {
325 goto finish;
327 bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
328 false);
331 ret = 0;
333 bdrv_dirty_bitmap_deserialize_finish(bitmap);
335 finish:
336 g_free(buf);
338 return ret;
341 static BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
342 Qcow2Bitmap *bm, Error **errp)
344 int ret;
345 uint64_t *bitmap_table = NULL;
346 uint32_t granularity;
347 BdrvDirtyBitmap *bitmap = NULL;
349 if (bm->flags & BME_FLAG_IN_USE) {
350 error_setg(errp, "Bitmap '%s' is in use", bm->name);
351 goto fail;
354 ret = bitmap_table_load(bs, &bm->table, &bitmap_table);
355 if (ret < 0) {
356 error_setg_errno(errp, -ret,
357 "Could not read bitmap_table table from image for "
358 "bitmap '%s'", bm->name);
359 goto fail;
362 granularity = 1U << bm->granularity_bits;
363 bitmap = bdrv_create_dirty_bitmap(bs, granularity, bm->name, errp);
364 if (bitmap == NULL) {
365 goto fail;
368 ret = load_bitmap_data(bs, bitmap_table, bm->table.size, bitmap);
369 if (ret < 0) {
370 error_setg_errno(errp, -ret, "Could not read bitmap '%s' from image",
371 bm->name);
372 goto fail;
375 g_free(bitmap_table);
376 return bitmap;
378 fail:
379 g_free(bitmap_table);
380 if (bitmap != NULL) {
381 bdrv_release_dirty_bitmap(bs, bitmap);
384 return NULL;
388 * Bitmap List
392 * Bitmap List private functions
393 * Only Bitmap List knows about bitmap directory structure in Qcow2.
396 static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry *entry)
398 be64_to_cpus(&entry->bitmap_table_offset);
399 be32_to_cpus(&entry->bitmap_table_size);
400 be32_to_cpus(&entry->flags);
401 be16_to_cpus(&entry->name_size);
402 be32_to_cpus(&entry->extra_data_size);
405 static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry)
407 cpu_to_be64s(&entry->bitmap_table_offset);
408 cpu_to_be32s(&entry->bitmap_table_size);
409 cpu_to_be32s(&entry->flags);
410 cpu_to_be16s(&entry->name_size);
411 cpu_to_be32s(&entry->extra_data_size);
414 static inline int calc_dir_entry_size(size_t name_size, size_t extra_data_size)
416 return align_offset(sizeof(Qcow2BitmapDirEntry) +
417 name_size + extra_data_size, 8);
420 static inline int dir_entry_size(Qcow2BitmapDirEntry *entry)
422 return calc_dir_entry_size(entry->name_size, entry->extra_data_size);
425 static inline const char *dir_entry_name_field(Qcow2BitmapDirEntry *entry)
427 return (const char *)(entry + 1) + entry->extra_data_size;
430 static inline char *dir_entry_copy_name(Qcow2BitmapDirEntry *entry)
432 const char *name_field = dir_entry_name_field(entry);
433 return g_strndup(name_field, entry->name_size);
436 static inline Qcow2BitmapDirEntry *next_dir_entry(Qcow2BitmapDirEntry *entry)
438 return (Qcow2BitmapDirEntry *)((uint8_t *)entry + dir_entry_size(entry));
441 static int check_dir_entry(BlockDriverState *bs, Qcow2BitmapDirEntry *entry)
443 BDRVQcow2State *s = bs->opaque;
444 uint64_t phys_bitmap_bytes;
445 int64_t len;
447 bool fail = (entry->bitmap_table_size == 0) ||
448 (entry->bitmap_table_offset == 0) ||
449 (entry->bitmap_table_offset % s->cluster_size) ||
450 (entry->bitmap_table_size > BME_MAX_TABLE_SIZE) ||
451 (entry->granularity_bits > BME_MAX_GRANULARITY_BITS) ||
452 (entry->granularity_bits < BME_MIN_GRANULARITY_BITS) ||
453 (entry->flags & BME_RESERVED_FLAGS) ||
454 (entry->name_size > BME_MAX_NAME_SIZE) ||
455 (entry->type != BT_DIRTY_TRACKING_BITMAP);
457 if (fail) {
458 return -EINVAL;
461 phys_bitmap_bytes = (uint64_t)entry->bitmap_table_size * s->cluster_size;
462 len = bdrv_getlength(bs);
464 if (len < 0) {
465 return len;
468 fail = (phys_bitmap_bytes > BME_MAX_PHYS_SIZE) ||
469 (len > ((phys_bitmap_bytes * 8) << entry->granularity_bits));
471 return fail ? -EINVAL : 0;
474 static inline void bitmap_directory_to_be(uint8_t *dir, size_t size)
476 uint8_t *end = dir + size;
477 while (dir < end) {
478 Qcow2BitmapDirEntry *e = (Qcow2BitmapDirEntry *)dir;
479 dir += dir_entry_size(e);
481 bitmap_dir_entry_to_be(e);
486 * Bitmap List public functions
489 static void bitmap_free(Qcow2Bitmap *bm)
491 if (bm == NULL) {
492 return;
495 g_free(bm->name);
496 g_free(bm);
499 static void bitmap_list_free(Qcow2BitmapList *bm_list)
501 Qcow2Bitmap *bm;
503 if (bm_list == NULL) {
504 return;
507 while ((bm = QSIMPLEQ_FIRST(bm_list)) != NULL) {
508 QSIMPLEQ_REMOVE_HEAD(bm_list, entry);
509 bitmap_free(bm);
512 g_free(bm_list);
515 static Qcow2BitmapList *bitmap_list_new(void)
517 Qcow2BitmapList *bm_list = g_new(Qcow2BitmapList, 1);
518 QSIMPLEQ_INIT(bm_list);
520 return bm_list;
523 static uint32_t bitmap_list_count(Qcow2BitmapList *bm_list)
525 Qcow2Bitmap *bm;
526 uint32_t nb_bitmaps = 0;
528 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
529 nb_bitmaps++;
532 return nb_bitmaps;
535 /* bitmap_list_load
536 * Get bitmap list from qcow2 image. Actually reads bitmap directory,
537 * checks it and convert to bitmap list.
539 static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset,
540 uint64_t size, Error **errp)
542 int ret;
543 BDRVQcow2State *s = bs->opaque;
544 uint8_t *dir, *dir_end;
545 Qcow2BitmapDirEntry *e;
546 uint32_t nb_dir_entries = 0;
547 Qcow2BitmapList *bm_list = NULL;
549 if (size == 0) {
550 error_setg(errp, "Requested bitmap directory size is zero");
551 return NULL;
554 if (size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
555 error_setg(errp, "Requested bitmap directory size is too big");
556 return NULL;
559 dir = g_try_malloc(size);
560 if (dir == NULL) {
561 error_setg(errp, "Failed to allocate space for bitmap directory");
562 return NULL;
564 dir_end = dir + size;
566 ret = bdrv_pread(bs->file, offset, dir, size);
567 if (ret < 0) {
568 error_setg_errno(errp, -ret, "Failed to read bitmap directory");
569 goto fail;
572 bm_list = bitmap_list_new();
573 for (e = (Qcow2BitmapDirEntry *)dir;
574 e < (Qcow2BitmapDirEntry *)dir_end;
575 e = next_dir_entry(e))
577 Qcow2Bitmap *bm;
579 if ((uint8_t *)(e + 1) > dir_end) {
580 goto broken_dir;
583 if (++nb_dir_entries > s->nb_bitmaps) {
584 error_setg(errp, "More bitmaps found than specified in header"
585 " extension");
586 goto fail;
588 bitmap_dir_entry_to_cpu(e);
590 if ((uint8_t *)next_dir_entry(e) > dir_end) {
591 goto broken_dir;
594 if (e->extra_data_size != 0) {
595 error_setg(errp, "Bitmap extra data is not supported");
596 goto fail;
599 ret = check_dir_entry(bs, e);
600 if (ret < 0) {
601 error_setg(errp, "Bitmap '%.*s' doesn't satisfy the constraints",
602 e->name_size, dir_entry_name_field(e));
603 goto fail;
606 bm = g_new0(Qcow2Bitmap, 1);
607 bm->table.offset = e->bitmap_table_offset;
608 bm->table.size = e->bitmap_table_size;
609 bm->flags = e->flags;
610 bm->granularity_bits = e->granularity_bits;
611 bm->name = dir_entry_copy_name(e);
612 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry);
615 if (nb_dir_entries != s->nb_bitmaps) {
616 error_setg(errp, "Less bitmaps found than specified in header"
617 " extension");
618 goto fail;
621 if ((uint8_t *)e != dir_end) {
622 goto broken_dir;
625 g_free(dir);
626 return bm_list;
628 broken_dir:
629 ret = -EINVAL;
630 error_setg(errp, "Broken bitmap directory");
632 fail:
633 g_free(dir);
634 bitmap_list_free(bm_list);
636 return NULL;
639 int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
640 void **refcount_table,
641 int64_t *refcount_table_size)
643 int ret;
644 BDRVQcow2State *s = bs->opaque;
645 Qcow2BitmapList *bm_list;
646 Qcow2Bitmap *bm;
648 if (s->nb_bitmaps == 0) {
649 return 0;
652 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,
653 s->bitmap_directory_offset,
654 s->bitmap_directory_size);
655 if (ret < 0) {
656 return ret;
659 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
660 s->bitmap_directory_size, NULL);
661 if (bm_list == NULL) {
662 res->corruptions++;
663 return -EINVAL;
666 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
667 uint64_t *bitmap_table = NULL;
668 int i;
670 ret = qcow2_inc_refcounts_imrt(bs, res,
671 refcount_table, refcount_table_size,
672 bm->table.offset,
673 bm->table.size * sizeof(uint64_t));
674 if (ret < 0) {
675 goto out;
678 ret = bitmap_table_load(bs, &bm->table, &bitmap_table);
679 if (ret < 0) {
680 res->corruptions++;
681 goto out;
684 for (i = 0; i < bm->table.size; ++i) {
685 uint64_t entry = bitmap_table[i];
686 uint64_t offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
688 if (check_table_entry(entry, s->cluster_size) < 0) {
689 res->corruptions++;
690 continue;
693 if (offset == 0) {
694 continue;
697 ret = qcow2_inc_refcounts_imrt(bs, res,
698 refcount_table, refcount_table_size,
699 offset, s->cluster_size);
700 if (ret < 0) {
701 g_free(bitmap_table);
702 goto out;
706 g_free(bitmap_table);
709 out:
710 bitmap_list_free(bm_list);
712 return ret;
715 /* bitmap_list_store
716 * Store bitmap list to qcow2 image as a bitmap directory.
717 * Everything is checked.
719 static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list,
720 uint64_t *offset, uint64_t *size, bool in_place)
722 int ret;
723 uint8_t *dir;
724 int64_t dir_offset = 0;
725 uint64_t dir_size = 0;
726 Qcow2Bitmap *bm;
727 Qcow2BitmapDirEntry *e;
729 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
730 dir_size += calc_dir_entry_size(strlen(bm->name), 0);
733 if (dir_size == 0 || dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
734 return -EINVAL;
737 if (in_place) {
738 if (*size != dir_size || *offset == 0) {
739 return -EINVAL;
742 dir_offset = *offset;
745 dir = g_try_malloc(dir_size);
746 if (dir == NULL) {
747 return -ENOMEM;
750 e = (Qcow2BitmapDirEntry *)dir;
751 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
752 e->bitmap_table_offset = bm->table.offset;
753 e->bitmap_table_size = bm->table.size;
754 e->flags = bm->flags;
755 e->type = BT_DIRTY_TRACKING_BITMAP;
756 e->granularity_bits = bm->granularity_bits;
757 e->name_size = strlen(bm->name);
758 e->extra_data_size = 0;
759 memcpy(e + 1, bm->name, e->name_size);
761 if (check_dir_entry(bs, e) < 0) {
762 ret = -EINVAL;
763 goto fail;
766 e = next_dir_entry(e);
769 bitmap_directory_to_be(dir, dir_size);
771 if (!in_place) {
772 dir_offset = qcow2_alloc_clusters(bs, dir_size);
773 if (dir_offset < 0) {
774 ret = dir_offset;
775 goto fail;
779 ret = qcow2_pre_write_overlap_check(bs, 0, dir_offset, dir_size);
780 if (ret < 0) {
781 goto fail;
784 ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size);
785 if (ret < 0) {
786 goto fail;
789 g_free(dir);
791 if (!in_place) {
792 *size = dir_size;
793 *offset = dir_offset;
796 return 0;
798 fail:
799 g_free(dir);
801 if (!in_place && dir_offset > 0) {
802 qcow2_free_clusters(bs, dir_offset, dir_size, QCOW2_DISCARD_OTHER);
805 return ret;
809 * Bitmap List end
812 static int update_ext_header_and_dir_in_place(BlockDriverState *bs,
813 Qcow2BitmapList *bm_list)
815 BDRVQcow2State *s = bs->opaque;
816 int ret;
818 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS) ||
819 bm_list == NULL || QSIMPLEQ_EMPTY(bm_list) ||
820 bitmap_list_count(bm_list) != s->nb_bitmaps)
822 return -EINVAL;
825 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
826 ret = update_header_sync(bs);
827 if (ret < 0) {
828 /* Two variants are possible here:
829 * 1. Autoclear flag is dropped, all bitmaps will be lost.
830 * 2. Autoclear flag is not dropped, old state is left.
832 return ret;
835 /* autoclear bit is not set, so we can safely update bitmap directory */
837 ret = bitmap_list_store(bs, bm_list, &s->bitmap_directory_offset,
838 &s->bitmap_directory_size, true);
839 if (ret < 0) {
840 /* autoclear bit is cleared, so all leaked clusters would be removed on
841 * qemu-img check */
842 return ret;
845 ret = update_header_sync(bs);
846 if (ret < 0) {
847 /* autoclear bit is cleared, so all leaked clusters would be removed on
848 * qemu-img check */
849 return ret;
852 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
853 return update_header_sync(bs);
854 /* If final update_header_sync() fails, two variants are possible:
855 * 1. Autoclear flag is not set, all bitmaps will be lost.
856 * 2. Autoclear flag is set, header and directory are successfully updated.
860 static int update_ext_header_and_dir(BlockDriverState *bs,
861 Qcow2BitmapList *bm_list)
863 BDRVQcow2State *s = bs->opaque;
864 int ret;
865 uint64_t new_offset = 0;
866 uint64_t new_size = 0;
867 uint32_t new_nb_bitmaps = 0;
868 uint64_t old_offset = s->bitmap_directory_offset;
869 uint64_t old_size = s->bitmap_directory_size;
870 uint32_t old_nb_bitmaps = s->nb_bitmaps;
871 uint64_t old_autocl = s->autoclear_features;
873 if (bm_list != NULL && !QSIMPLEQ_EMPTY(bm_list)) {
874 new_nb_bitmaps = bitmap_list_count(bm_list);
876 if (new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
877 return -EINVAL;
880 ret = bitmap_list_store(bs, bm_list, &new_offset, &new_size, false);
881 if (ret < 0) {
882 return ret;
885 ret = bdrv_flush(bs->file->bs);
886 if (ret < 0) {
887 goto fail;
890 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
891 } else {
892 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
895 s->bitmap_directory_offset = new_offset;
896 s->bitmap_directory_size = new_size;
897 s->nb_bitmaps = new_nb_bitmaps;
899 ret = update_header_sync(bs);
900 if (ret < 0) {
901 goto fail;
904 if (old_size > 0) {
905 qcow2_free_clusters(bs, old_offset, old_size, QCOW2_DISCARD_OTHER);
908 return 0;
910 fail:
911 if (new_offset > 0) {
912 qcow2_free_clusters(bs, new_offset, new_size, QCOW2_DISCARD_OTHER);
915 s->bitmap_directory_offset = old_offset;
916 s->bitmap_directory_size = old_size;
917 s->nb_bitmaps = old_nb_bitmaps;
918 s->autoclear_features = old_autocl;
920 return ret;
923 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
924 static void release_dirty_bitmap_helper(gpointer bitmap,
925 gpointer bs)
927 bdrv_release_dirty_bitmap(bs, bitmap);
930 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
931 static void set_readonly_helper(gpointer bitmap, gpointer value)
933 bdrv_dirty_bitmap_set_readonly(bitmap, (bool)value);
936 /* qcow2_load_dirty_bitmaps()
937 * Return value is a hint for caller: true means that the Qcow2 header was
938 * updated. (false doesn't mean that the header should be updated by the
939 * caller, it just means that updating was not needed or the image cannot be
940 * written to).
941 * On failure the function returns false.
943 bool qcow2_load_dirty_bitmaps(BlockDriverState *bs, Error **errp)
945 BDRVQcow2State *s = bs->opaque;
946 Qcow2BitmapList *bm_list;
947 Qcow2Bitmap *bm;
948 GSList *created_dirty_bitmaps = NULL;
949 bool header_updated = false;
951 if (s->nb_bitmaps == 0) {
952 /* No bitmaps - nothing to do */
953 return false;
956 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
957 s->bitmap_directory_size, errp);
958 if (bm_list == NULL) {
959 return false;
962 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
963 if (!(bm->flags & BME_FLAG_IN_USE)) {
964 BdrvDirtyBitmap *bitmap = load_bitmap(bs, bm, errp);
965 if (bitmap == NULL) {
966 goto fail;
969 if (!(bm->flags & BME_FLAG_AUTO)) {
970 bdrv_disable_dirty_bitmap(bitmap);
972 bdrv_dirty_bitmap_set_persistance(bitmap, true);
973 bm->flags |= BME_FLAG_IN_USE;
974 created_dirty_bitmaps =
975 g_slist_append(created_dirty_bitmaps, bitmap);
979 if (created_dirty_bitmaps != NULL) {
980 if (can_write(bs)) {
981 /* in_use flags must be updated */
982 int ret = update_ext_header_and_dir_in_place(bs, bm_list);
983 if (ret < 0) {
984 error_setg_errno(errp, -ret, "Can't update bitmap directory");
985 goto fail;
987 header_updated = true;
988 } else {
989 g_slist_foreach(created_dirty_bitmaps, set_readonly_helper,
990 (gpointer)true);
994 g_slist_free(created_dirty_bitmaps);
995 bitmap_list_free(bm_list);
997 return header_updated;
999 fail:
1000 g_slist_foreach(created_dirty_bitmaps, release_dirty_bitmap_helper, bs);
1001 g_slist_free(created_dirty_bitmaps);
1002 bitmap_list_free(bm_list);
1004 return false;
1007 int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp)
1009 BDRVQcow2State *s = bs->opaque;
1010 Qcow2BitmapList *bm_list;
1011 Qcow2Bitmap *bm;
1012 GSList *ro_dirty_bitmaps = NULL;
1013 int ret = 0;
1015 if (s->nb_bitmaps == 0) {
1016 /* No bitmaps - nothing to do */
1017 return 0;
1020 if (!can_write(bs)) {
1021 error_setg(errp, "Can't write to the image on reopening bitmaps rw");
1022 return -EINVAL;
1025 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1026 s->bitmap_directory_size, errp);
1027 if (bm_list == NULL) {
1028 return -EINVAL;
1031 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1032 if (!(bm->flags & BME_FLAG_IN_USE)) {
1033 BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name);
1034 if (bitmap == NULL) {
1035 continue;
1038 if (!bdrv_dirty_bitmap_readonly(bitmap)) {
1039 error_setg(errp, "Bitmap %s is not readonly but not marked"
1040 "'IN_USE' in the image. Something went wrong,"
1041 "all the bitmaps may be corrupted", bm->name);
1042 ret = -EINVAL;
1043 goto out;
1046 bm->flags |= BME_FLAG_IN_USE;
1047 ro_dirty_bitmaps = g_slist_append(ro_dirty_bitmaps, bitmap);
1051 if (ro_dirty_bitmaps != NULL) {
1052 /* in_use flags must be updated */
1053 ret = update_ext_header_and_dir_in_place(bs, bm_list);
1054 if (ret < 0) {
1055 error_setg_errno(errp, -ret, "Can't update bitmap directory");
1056 goto out;
1058 g_slist_foreach(ro_dirty_bitmaps, set_readonly_helper, false);
1061 out:
1062 g_slist_free(ro_dirty_bitmaps);
1063 bitmap_list_free(bm_list);
1065 return ret;
1068 /* store_bitmap_data()
1069 * Store bitmap to image, filling bitmap table accordingly.
1071 static uint64_t *store_bitmap_data(BlockDriverState *bs,
1072 BdrvDirtyBitmap *bitmap,
1073 uint32_t *bitmap_table_size, Error **errp)
1075 int ret;
1076 BDRVQcow2State *s = bs->opaque;
1077 int64_t offset;
1078 uint64_t limit;
1079 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
1080 const char *bm_name = bdrv_dirty_bitmap_name(bitmap);
1081 uint8_t *buf = NULL;
1082 BdrvDirtyBitmapIter *dbi;
1083 uint64_t *tb;
1084 uint64_t tb_size =
1085 size_to_clusters(s,
1086 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
1088 if (tb_size > BME_MAX_TABLE_SIZE ||
1089 tb_size * s->cluster_size > BME_MAX_PHYS_SIZE)
1091 error_setg(errp, "Bitmap '%s' is too big", bm_name);
1092 return NULL;
1095 tb = g_try_new0(uint64_t, tb_size);
1096 if (tb == NULL) {
1097 error_setg(errp, "No memory");
1098 return NULL;
1101 dbi = bdrv_dirty_iter_new(bitmap);
1102 buf = g_malloc(s->cluster_size);
1103 limit = bytes_covered_by_bitmap_cluster(s, bitmap);
1104 assert(DIV_ROUND_UP(bm_size, limit) == tb_size);
1106 while ((offset = bdrv_dirty_iter_next(dbi)) >= 0) {
1107 uint64_t cluster = offset / limit;
1108 uint64_t end, write_size;
1109 int64_t off;
1112 * We found the first dirty offset, but want to write out the
1113 * entire cluster of the bitmap that includes that offset,
1114 * including any leading zero bits.
1116 offset = QEMU_ALIGN_DOWN(offset, limit);
1117 end = MIN(bm_size, offset + limit);
1118 write_size = bdrv_dirty_bitmap_serialization_size(bitmap, offset,
1119 end - offset);
1120 assert(write_size <= s->cluster_size);
1122 off = qcow2_alloc_clusters(bs, s->cluster_size);
1123 if (off < 0) {
1124 error_setg_errno(errp, -off,
1125 "Failed to allocate clusters for bitmap '%s'",
1126 bm_name);
1127 goto fail;
1129 tb[cluster] = off;
1131 bdrv_dirty_bitmap_serialize_part(bitmap, buf, offset, end - offset);
1132 if (write_size < s->cluster_size) {
1133 memset(buf + write_size, 0, s->cluster_size - write_size);
1136 ret = qcow2_pre_write_overlap_check(bs, 0, off, s->cluster_size);
1137 if (ret < 0) {
1138 error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1139 goto fail;
1142 ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size);
1143 if (ret < 0) {
1144 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1145 bm_name);
1146 goto fail;
1149 if (end >= bm_size) {
1150 break;
1153 bdrv_set_dirty_iter(dbi, end);
1156 *bitmap_table_size = tb_size;
1157 g_free(buf);
1158 bdrv_dirty_iter_free(dbi);
1160 return tb;
1162 fail:
1163 clear_bitmap_table(bs, tb, tb_size);
1164 g_free(buf);
1165 bdrv_dirty_iter_free(dbi);
1166 g_free(tb);
1168 return NULL;
1171 /* store_bitmap()
1172 * Store bm->dirty_bitmap to qcow2.
1173 * Set bm->table_offset and bm->table_size accordingly.
1175 static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
1177 int ret;
1178 uint64_t *tb;
1179 int64_t tb_offset;
1180 uint32_t tb_size;
1181 BdrvDirtyBitmap *bitmap = bm->dirty_bitmap;
1182 const char *bm_name;
1184 assert(bitmap != NULL);
1186 bm_name = bdrv_dirty_bitmap_name(bitmap);
1188 tb = store_bitmap_data(bs, bitmap, &tb_size, errp);
1189 if (tb == NULL) {
1190 return -EINVAL;
1193 assert(tb_size <= BME_MAX_TABLE_SIZE);
1194 tb_offset = qcow2_alloc_clusters(bs, tb_size * sizeof(tb[0]));
1195 if (tb_offset < 0) {
1196 error_setg_errno(errp, -tb_offset,
1197 "Failed to allocate clusters for bitmap '%s'",
1198 bm_name);
1199 ret = tb_offset;
1200 goto fail;
1203 ret = qcow2_pre_write_overlap_check(bs, 0, tb_offset,
1204 tb_size * sizeof(tb[0]));
1205 if (ret < 0) {
1206 error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1207 goto fail;
1210 bitmap_table_to_be(tb, tb_size);
1211 ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]));
1212 if (ret < 0) {
1213 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1214 bm_name);
1215 goto fail;
1218 g_free(tb);
1220 bm->table.offset = tb_offset;
1221 bm->table.size = tb_size;
1223 return 0;
1225 fail:
1226 clear_bitmap_table(bs, tb, tb_size);
1228 if (tb_offset > 0) {
1229 qcow2_free_clusters(bs, tb_offset, tb_size * sizeof(tb[0]),
1230 QCOW2_DISCARD_OTHER);
1233 g_free(tb);
1235 return ret;
1238 static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,
1239 const char *name)
1241 Qcow2Bitmap *bm;
1243 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1244 if (strcmp(name, bm->name) == 0) {
1245 return bm;
1249 return NULL;
1252 void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs,
1253 const char *name,
1254 Error **errp)
1256 int ret;
1257 BDRVQcow2State *s = bs->opaque;
1258 Qcow2Bitmap *bm;
1259 Qcow2BitmapList *bm_list;
1261 if (s->nb_bitmaps == 0) {
1262 /* Absence of the bitmap is not an error: see explanation above
1263 * bdrv_remove_persistent_dirty_bitmap() definition. */
1264 return;
1267 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1268 s->bitmap_directory_size, errp);
1269 if (bm_list == NULL) {
1270 return;
1273 bm = find_bitmap_by_name(bm_list, name);
1274 if (bm == NULL) {
1275 goto fail;
1278 QSIMPLEQ_REMOVE(bm_list, bm, Qcow2Bitmap, entry);
1280 ret = update_ext_header_and_dir(bs, bm_list);
1281 if (ret < 0) {
1282 error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1283 goto fail;
1286 free_bitmap_clusters(bs, &bm->table);
1288 fail:
1289 bitmap_free(bm);
1290 bitmap_list_free(bm_list);
1293 void qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, Error **errp)
1295 BdrvDirtyBitmap *bitmap;
1296 BDRVQcow2State *s = bs->opaque;
1297 uint32_t new_nb_bitmaps = s->nb_bitmaps;
1298 uint64_t new_dir_size = s->bitmap_directory_size;
1299 int ret;
1300 Qcow2BitmapList *bm_list;
1301 Qcow2Bitmap *bm;
1302 Qcow2BitmapTableList drop_tables;
1303 Qcow2BitmapTable *tb, *tb_next;
1305 if (!bdrv_has_changed_persistent_bitmaps(bs)) {
1306 /* nothing to do */
1307 return;
1310 if (!can_write(bs)) {
1311 error_setg(errp, "No write access");
1312 return;
1315 QSIMPLEQ_INIT(&drop_tables);
1317 if (s->nb_bitmaps == 0) {
1318 bm_list = bitmap_list_new();
1319 } else {
1320 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1321 s->bitmap_directory_size, errp);
1322 if (bm_list == NULL) {
1323 return;
1327 /* check constraints and names */
1328 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL;
1329 bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
1331 const char *name = bdrv_dirty_bitmap_name(bitmap);
1332 uint32_t granularity = bdrv_dirty_bitmap_granularity(bitmap);
1333 Qcow2Bitmap *bm;
1335 if (!bdrv_dirty_bitmap_get_persistance(bitmap) ||
1336 bdrv_dirty_bitmap_readonly(bitmap))
1338 continue;
1341 if (check_constraints_on_bitmap(bs, name, granularity, errp) < 0) {
1342 error_prepend(errp, "Bitmap '%s' doesn't satisfy the constraints: ",
1343 name);
1344 goto fail;
1347 bm = find_bitmap_by_name(bm_list, name);
1348 if (bm == NULL) {
1349 if (++new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
1350 error_setg(errp, "Too many persistent bitmaps");
1351 goto fail;
1354 new_dir_size += calc_dir_entry_size(strlen(name), 0);
1355 if (new_dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
1356 error_setg(errp, "Bitmap directory is too large");
1357 goto fail;
1360 bm = g_new0(Qcow2Bitmap, 1);
1361 bm->name = g_strdup(name);
1362 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry);
1363 } else {
1364 if (!(bm->flags & BME_FLAG_IN_USE)) {
1365 error_setg(errp, "Bitmap '%s' already exists in the image",
1366 name);
1367 goto fail;
1369 tb = g_memdup(&bm->table, sizeof(bm->table));
1370 bm->table.offset = 0;
1371 bm->table.size = 0;
1372 QSIMPLEQ_INSERT_TAIL(&drop_tables, tb, entry);
1374 bm->flags = bdrv_dirty_bitmap_enabled(bitmap) ? BME_FLAG_AUTO : 0;
1375 bm->granularity_bits = ctz32(bdrv_dirty_bitmap_granularity(bitmap));
1376 bm->dirty_bitmap = bitmap;
1379 /* allocate clusters and store bitmaps */
1380 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1381 if (bm->dirty_bitmap == NULL) {
1382 continue;
1385 ret = store_bitmap(bs, bm, errp);
1386 if (ret < 0) {
1387 goto fail;
1391 ret = update_ext_header_and_dir(bs, bm_list);
1392 if (ret < 0) {
1393 error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1394 goto fail;
1397 /* Bitmap directory was successfully updated, so, old data can be dropped.
1398 * TODO it is better to reuse these clusters */
1399 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1400 free_bitmap_clusters(bs, tb);
1401 g_free(tb);
1404 bitmap_list_free(bm_list);
1405 return;
1407 fail:
1408 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1409 if (bm->dirty_bitmap == NULL || bm->table.offset == 0) {
1410 continue;
1413 free_bitmap_clusters(bs, &bm->table);
1416 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1417 g_free(tb);
1420 bitmap_list_free(bm_list);
1423 int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp)
1425 BdrvDirtyBitmap *bitmap;
1426 Error *local_err = NULL;
1428 qcow2_store_persistent_dirty_bitmaps(bs, &local_err);
1429 if (local_err != NULL) {
1430 error_propagate(errp, local_err);
1431 return -EINVAL;
1434 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL;
1435 bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
1437 if (bdrv_dirty_bitmap_get_persistance(bitmap)) {
1438 bdrv_dirty_bitmap_set_readonly(bitmap, true);
1442 return 0;
1445 bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,
1446 const char *name,
1447 uint32_t granularity,
1448 Error **errp)
1450 BDRVQcow2State *s = bs->opaque;
1451 bool found;
1452 Qcow2BitmapList *bm_list;
1454 if (s->qcow_version < 3) {
1455 /* Without autoclear_features, we would always have to assume
1456 * that a program without persistent dirty bitmap support has
1457 * accessed this qcow2 file when opening it, and would thus
1458 * have to drop all dirty bitmaps (defeating their purpose).
1460 error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files");
1461 goto fail;
1464 if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) {
1465 goto fail;
1468 if (s->nb_bitmaps == 0) {
1469 return true;
1472 if (s->nb_bitmaps >= QCOW2_MAX_BITMAPS) {
1473 error_setg(errp,
1474 "Maximum number of persistent bitmaps is already reached");
1475 goto fail;
1478 if (s->bitmap_directory_size + calc_dir_entry_size(strlen(name), 0) >
1479 QCOW2_MAX_BITMAP_DIRECTORY_SIZE)
1481 error_setg(errp, "Not enough space in the bitmap directory");
1482 goto fail;
1485 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1486 s->bitmap_directory_size, errp);
1487 if (bm_list == NULL) {
1488 goto fail;
1491 found = find_bitmap_by_name(bm_list, name);
1492 bitmap_list_free(bm_list);
1493 if (found) {
1494 error_setg(errp, "Bitmap with the same name is already stored");
1495 goto fail;
1498 return true;
1500 fail:
1501 error_prepend(errp, "Can't make bitmap '%s' persistent in '%s': ",
1502 name, bdrv_get_device_or_node_name(bs));
1503 return false;