1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "qemu/osdep.h"
29#include "qapi/error.h"
30#include "qemu/cutils.h"
31
32#include "qcow2.h"
33
34
35
36
37
38
39#define BME_MAX_TABLE_SIZE 0x8000000
40#define BME_MAX_PHYS_SIZE 0x20000000
41#define BME_MAX_GRANULARITY_BITS 31
42#define BME_MIN_GRANULARITY_BITS 9
43#define BME_MAX_NAME_SIZE 1023
44
45#if BME_MAX_TABLE_SIZE * 8ULL > INT_MAX
46#error In the code bitmap table physical size assumed to fit into int
47#endif
48
49
50#define BME_RESERVED_FLAGS 0xfffffffcU
51#define BME_FLAG_IN_USE (1U << 0)
52#define BME_FLAG_AUTO (1U << 1)
53
54
55#define BME_TABLE_ENTRY_RESERVED_MASK 0xff000000000001feULL
56#define BME_TABLE_ENTRY_OFFSET_MASK 0x00fffffffffffe00ULL
57#define BME_TABLE_ENTRY_FLAG_ALL_ONES (1ULL << 0)
58
59typedef struct QEMU_PACKED Qcow2BitmapDirEntry {
60
61 uint64_t bitmap_table_offset;
62
63 uint32_t bitmap_table_size;
64 uint32_t flags;
65
66 uint8_t type;
67 uint8_t granularity_bits;
68 uint16_t name_size;
69 uint32_t extra_data_size;
70
71
72} Qcow2BitmapDirEntry;
73
74typedef struct Qcow2BitmapTable {
75 uint64_t offset;
76 uint32_t size;
77 QSIMPLEQ_ENTRY(Qcow2BitmapTable) entry;
78} Qcow2BitmapTable;
79
80typedef struct Qcow2Bitmap {
81 Qcow2BitmapTable table;
82 uint32_t flags;
83 uint8_t granularity_bits;
84 char *name;
85
86 BdrvDirtyBitmap *dirty_bitmap;
87
88 QSIMPLEQ_ENTRY(Qcow2Bitmap) entry;
89} Qcow2Bitmap;
90typedef QSIMPLEQ_HEAD(Qcow2BitmapList, Qcow2Bitmap) Qcow2BitmapList;
91
92typedef enum BitmapType {
93 BT_DIRTY_TRACKING_BITMAP = 1
94} BitmapType;
95
96static inline bool can_write(BlockDriverState *bs)
97{
98 return !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
99}
100
101static int update_header_sync(BlockDriverState *bs)
102{
103 int ret;
104
105 ret = qcow2_update_header(bs);
106 if (ret < 0) {
107 return ret;
108 }
109
110 return bdrv_flush(bs->file->bs);
111}
112
113static inline void bitmap_table_to_be(uint64_t *bitmap_table, size_t size)
114{
115 size_t i;
116
117 for (i = 0; i < size; ++i) {
118 bitmap_table[i] = cpu_to_be64(bitmap_table[i]);
119 }
120}
121
122static int check_table_entry(uint64_t entry, int cluster_size)
123{
124 uint64_t offset;
125
126 if (entry & BME_TABLE_ENTRY_RESERVED_MASK) {
127 return -EINVAL;
128 }
129
130 offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
131 if (offset != 0) {
132
133 if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) {
134 return -EINVAL;
135 }
136
137 if (offset % cluster_size != 0) {
138 return -EINVAL;
139 }
140 }
141
142 return 0;
143}
144
145static int64_t get_bitmap_bytes_needed(int64_t len, uint32_t granularity)
146{
147 int64_t num_bits = DIV_ROUND_UP(len, granularity);
148
149 return DIV_ROUND_UP(num_bits, 8);
150}
151
152static int check_constraints_on_bitmap(BlockDriverState *bs,
153 const char *name,
154 uint32_t granularity,
155 Error **errp)
156{
157 BDRVQcow2State *s = bs->opaque;
158 int granularity_bits = ctz32(granularity);
159 int64_t len = bdrv_getlength(bs);
160 int64_t bitmap_bytes;
161
162 assert(granularity > 0);
163 assert((granularity & (granularity - 1)) == 0);
164
165 if (len < 0) {
166 error_setg_errno(errp, -len, "Failed to get size of '%s'",
167 bdrv_get_device_or_node_name(bs));
168 return len;
169 }
170
171 if (granularity_bits > BME_MAX_GRANULARITY_BITS) {
172 error_setg(errp, "Granularity exceeds maximum (%llu bytes)",
173 1ULL << BME_MAX_GRANULARITY_BITS);
174 return -EINVAL;
175 }
176 if (granularity_bits < BME_MIN_GRANULARITY_BITS) {
177 error_setg(errp, "Granularity is under minimum (%llu bytes)",
178 1ULL << BME_MIN_GRANULARITY_BITS);
179 return -EINVAL;
180 }
181
182 bitmap_bytes = get_bitmap_bytes_needed(len, granularity);
183 if ((bitmap_bytes > (uint64_t)BME_MAX_PHYS_SIZE) ||
184 (bitmap_bytes > (uint64_t)BME_MAX_TABLE_SIZE * s->cluster_size))
185 {
186 error_setg(errp, "Too much space will be occupied by the bitmap. "
187 "Use larger granularity");
188 return -EINVAL;
189 }
190
191 if (strlen(name) > BME_MAX_NAME_SIZE) {
192 error_setg(errp, "Name length exceeds maximum (%u characters)",
193 BME_MAX_NAME_SIZE);
194 return -EINVAL;
195 }
196
197 return 0;
198}
199
200static void clear_bitmap_table(BlockDriverState *bs, uint64_t *bitmap_table,
201 uint32_t bitmap_table_size)
202{
203 BDRVQcow2State *s = bs->opaque;
204 int i;
205
206 for (i = 0; i < bitmap_table_size; ++i) {
207 uint64_t addr = bitmap_table[i] & BME_TABLE_ENTRY_OFFSET_MASK;
208 if (!addr) {
209 continue;
210 }
211
212 qcow2_free_clusters(bs, addr, s->cluster_size, QCOW2_DISCARD_ALWAYS);
213 bitmap_table[i] = 0;
214 }
215}
216
217static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
218 uint64_t **bitmap_table)
219{
220 int ret;
221 BDRVQcow2State *s = bs->opaque;
222 uint32_t i;
223 uint64_t *table;
224
225 assert(tb->size != 0);
226 table = g_try_new(uint64_t, tb->size);
227 if (table == NULL) {
228 return -ENOMEM;
229 }
230
231 assert(tb->size <= BME_MAX_TABLE_SIZE);
232 ret = bdrv_pread(bs->file, tb->offset,
233 table, tb->size * sizeof(uint64_t));
234 if (ret < 0) {
235 goto fail;
236 }
237
238 for (i = 0; i < tb->size; ++i) {
239 table[i] = be64_to_cpu(table[i]);
240 ret = check_table_entry(table[i], s->cluster_size);
241 if (ret < 0) {
242 goto fail;
243 }
244 }
245
246 *bitmap_table = table;
247 return 0;
248
249fail:
250 g_free(table);
251
252 return ret;
253}
254
255static int free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb)
256{
257 int ret;
258 uint64_t *bitmap_table;
259
260 ret = bitmap_table_load(bs, tb, &bitmap_table);
261 if (ret < 0) {
262 return ret;
263 }
264
265 clear_bitmap_table(bs, bitmap_table, tb->size);
266 qcow2_free_clusters(bs, tb->offset, tb->size * sizeof(uint64_t),
267 QCOW2_DISCARD_OTHER);
268 g_free(bitmap_table);
269
270 tb->offset = 0;
271 tb->size = 0;
272
273 return 0;
274}
275
276
277static uint64_t bytes_covered_by_bitmap_cluster(const BDRVQcow2State *s,
278 const BdrvDirtyBitmap *bitmap)
279{
280 uint64_t granularity = bdrv_dirty_bitmap_granularity(bitmap);
281 uint64_t limit = granularity * (s->cluster_size << 3);
282
283 assert(QEMU_IS_ALIGNED(limit,
284 bdrv_dirty_bitmap_serialization_align(bitmap)));
285 return limit;
286}
287
288
289
290
291static int load_bitmap_data(BlockDriverState *bs,
292 const uint64_t *bitmap_table,
293 uint32_t bitmap_table_size,
294 BdrvDirtyBitmap *bitmap)
295{
296 int ret = 0;
297 BDRVQcow2State *s = bs->opaque;
298 uint64_t offset, limit;
299 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
300 uint8_t *buf = NULL;
301 uint64_t i, tab_size =
302 size_to_clusters(s,
303 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
304
305 if (tab_size != bitmap_table_size || tab_size > BME_MAX_TABLE_SIZE) {
306 return -EINVAL;
307 }
308
309 buf = g_malloc(s->cluster_size);
310 limit = bytes_covered_by_bitmap_cluster(s, bitmap);
311 for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) {
312 uint64_t count = MIN(bm_size - offset, limit);
313 uint64_t entry = bitmap_table[i];
314 uint64_t data_offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
315
316 assert(check_table_entry(entry, s->cluster_size) == 0);
317
318 if (data_offset == 0) {
319 if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) {
320 bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count,
321 false);
322 } else {
323
324
325 }
326 } else {
327 ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size);
328 if (ret < 0) {
329 goto finish;
330 }
331 bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
332 false);
333 }
334 }
335 ret = 0;
336
337 bdrv_dirty_bitmap_deserialize_finish(bitmap);
338
339finish:
340 g_free(buf);
341
342 return ret;
343}
344
345static BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
346 Qcow2Bitmap *bm, Error **errp)
347{
348 int ret;
349 uint64_t *bitmap_table = NULL;
350 uint32_t granularity;
351 BdrvDirtyBitmap *bitmap = NULL;
352
353 granularity = 1U << bm->granularity_bits;
354 bitmap = bdrv_create_dirty_bitmap(bs, granularity, bm->name, errp);
355 if (bitmap == NULL) {
356 goto fail;
357 }
358
359 if (bm->flags & BME_FLAG_IN_USE) {
360
361 return bitmap;
362 }
363
364 ret = bitmap_table_load(bs, &bm->table, &bitmap_table);
365 if (ret < 0) {
366 error_setg_errno(errp, -ret,
367 "Could not read bitmap_table table from image for "
368 "bitmap '%s'", bm->name);
369 goto fail;
370 }
371
372 ret = load_bitmap_data(bs, bitmap_table, bm->table.size, bitmap);
373 if (ret < 0) {
374 error_setg_errno(errp, -ret, "Could not read bitmap '%s' from image",
375 bm->name);
376 goto fail;
377 }
378
379 g_free(bitmap_table);
380 return bitmap;
381
382fail:
383 g_free(bitmap_table);
384 if (bitmap != NULL) {
385 bdrv_release_dirty_bitmap(bs, bitmap);
386 }
387
388 return NULL;
389}
390
391
392
393
394
395
396
397
398
399
400static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry *entry)
401{
402 entry->bitmap_table_offset = be64_to_cpu(entry->bitmap_table_offset);
403 entry->bitmap_table_size = be32_to_cpu(entry->bitmap_table_size);
404 entry->flags = be32_to_cpu(entry->flags);
405 entry->name_size = be16_to_cpu(entry->name_size);
406 entry->extra_data_size = be32_to_cpu(entry->extra_data_size);
407}
408
409static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry)
410{
411 entry->bitmap_table_offset = cpu_to_be64(entry->bitmap_table_offset);
412 entry->bitmap_table_size = cpu_to_be32(entry->bitmap_table_size);
413 entry->flags = cpu_to_be32(entry->flags);
414 entry->name_size = cpu_to_be16(entry->name_size);
415 entry->extra_data_size = cpu_to_be32(entry->extra_data_size);
416}
417
418static inline int calc_dir_entry_size(size_t name_size, size_t extra_data_size)
419{
420 int size = sizeof(Qcow2BitmapDirEntry) + name_size + extra_data_size;
421 return ROUND_UP(size, 8);
422}
423
424static inline int dir_entry_size(Qcow2BitmapDirEntry *entry)
425{
426 return calc_dir_entry_size(entry->name_size, entry->extra_data_size);
427}
428
429static inline const char *dir_entry_name_field(Qcow2BitmapDirEntry *entry)
430{
431 return (const char *)(entry + 1) + entry->extra_data_size;
432}
433
434static inline char *dir_entry_copy_name(Qcow2BitmapDirEntry *entry)
435{
436 const char *name_field = dir_entry_name_field(entry);
437 return g_strndup(name_field, entry->name_size);
438}
439
440static inline Qcow2BitmapDirEntry *next_dir_entry(Qcow2BitmapDirEntry *entry)
441{
442 return (Qcow2BitmapDirEntry *)((uint8_t *)entry + dir_entry_size(entry));
443}
444
445static int check_dir_entry(BlockDriverState *bs, Qcow2BitmapDirEntry *entry)
446{
447 BDRVQcow2State *s = bs->opaque;
448 uint64_t phys_bitmap_bytes;
449 int64_t len;
450
451 bool fail = (entry->bitmap_table_size == 0) ||
452 (entry->bitmap_table_offset == 0) ||
453 (entry->bitmap_table_offset % s->cluster_size) ||
454 (entry->bitmap_table_size > BME_MAX_TABLE_SIZE) ||
455 (entry->granularity_bits > BME_MAX_GRANULARITY_BITS) ||
456 (entry->granularity_bits < BME_MIN_GRANULARITY_BITS) ||
457 (entry->flags & BME_RESERVED_FLAGS) ||
458 (entry->name_size > BME_MAX_NAME_SIZE) ||
459 (entry->type != BT_DIRTY_TRACKING_BITMAP);
460
461 if (fail) {
462 return -EINVAL;
463 }
464
465 phys_bitmap_bytes = (uint64_t)entry->bitmap_table_size * s->cluster_size;
466 len = bdrv_getlength(bs);
467
468 if (len < 0) {
469 return len;
470 }
471
472 if (phys_bitmap_bytes > BME_MAX_PHYS_SIZE) {
473 return -EINVAL;
474 }
475
476 if (!(entry->flags & BME_FLAG_IN_USE) &&
477 (len > ((phys_bitmap_bytes * 8) << entry->granularity_bits)))
478 {
479
480
481
482
483
484
485
486
487 return -EINVAL;
488 }
489
490 return 0;
491}
492
493static inline void bitmap_directory_to_be(uint8_t *dir, size_t size)
494{
495 uint8_t *end = dir + size;
496 while (dir < end) {
497 Qcow2BitmapDirEntry *e = (Qcow2BitmapDirEntry *)dir;
498 dir += dir_entry_size(e);
499
500 bitmap_dir_entry_to_be(e);
501 }
502}
503
504
505
506
507
508static void bitmap_free(Qcow2Bitmap *bm)
509{
510 if (bm == NULL) {
511 return;
512 }
513
514 g_free(bm->name);
515 g_free(bm);
516}
517
518static void bitmap_list_free(Qcow2BitmapList *bm_list)
519{
520 Qcow2Bitmap *bm;
521
522 if (bm_list == NULL) {
523 return;
524 }
525
526 while ((bm = QSIMPLEQ_FIRST(bm_list)) != NULL) {
527 QSIMPLEQ_REMOVE_HEAD(bm_list, entry);
528 bitmap_free(bm);
529 }
530
531 g_free(bm_list);
532}
533
534static Qcow2BitmapList *bitmap_list_new(void)
535{
536 Qcow2BitmapList *bm_list = g_new(Qcow2BitmapList, 1);
537 QSIMPLEQ_INIT(bm_list);
538
539 return bm_list;
540}
541
542static uint32_t bitmap_list_count(Qcow2BitmapList *bm_list)
543{
544 Qcow2Bitmap *bm;
545 uint32_t nb_bitmaps = 0;
546
547 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
548 nb_bitmaps++;
549 }
550
551 return nb_bitmaps;
552}
553
554
555
556
557
558static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset,
559 uint64_t size, Error **errp)
560{
561 int ret;
562 BDRVQcow2State *s = bs->opaque;
563 uint8_t *dir, *dir_end;
564 Qcow2BitmapDirEntry *e;
565 uint32_t nb_dir_entries = 0;
566 Qcow2BitmapList *bm_list = NULL;
567
568 if (size == 0) {
569 error_setg(errp, "Requested bitmap directory size is zero");
570 return NULL;
571 }
572
573 if (size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
574 error_setg(errp, "Requested bitmap directory size is too big");
575 return NULL;
576 }
577
578 dir = g_try_malloc(size);
579 if (dir == NULL) {
580 error_setg(errp, "Failed to allocate space for bitmap directory");
581 return NULL;
582 }
583 dir_end = dir + size;
584
585 ret = bdrv_pread(bs->file, offset, dir, size);
586 if (ret < 0) {
587 error_setg_errno(errp, -ret, "Failed to read bitmap directory");
588 goto fail;
589 }
590
591 bm_list = bitmap_list_new();
592 for (e = (Qcow2BitmapDirEntry *)dir;
593 e < (Qcow2BitmapDirEntry *)dir_end;
594 e = next_dir_entry(e))
595 {
596 Qcow2Bitmap *bm;
597
598 if ((uint8_t *)(e + 1) > dir_end) {
599 goto broken_dir;
600 }
601
602 if (++nb_dir_entries > s->nb_bitmaps) {
603 error_setg(errp, "More bitmaps found than specified in header"
604 " extension");
605 goto fail;
606 }
607 bitmap_dir_entry_to_cpu(e);
608
609 if ((uint8_t *)next_dir_entry(e) > dir_end) {
610 goto broken_dir;
611 }
612
613 if (e->extra_data_size != 0) {
614 error_setg(errp, "Bitmap extra data is not supported");
615 goto fail;
616 }
617
618 ret = check_dir_entry(bs, e);
619 if (ret < 0) {
620 error_setg(errp, "Bitmap '%.*s' doesn't satisfy the constraints",
621 e->name_size, dir_entry_name_field(e));
622 goto fail;
623 }
624
625 bm = g_new0(Qcow2Bitmap, 1);
626 bm->table.offset = e->bitmap_table_offset;
627 bm->table.size = e->bitmap_table_size;
628 bm->flags = e->flags;
629 bm->granularity_bits = e->granularity_bits;
630 bm->name = dir_entry_copy_name(e);
631 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry);
632 }
633
634 if (nb_dir_entries != s->nb_bitmaps) {
635 error_setg(errp, "Less bitmaps found than specified in header"
636 " extension");
637 goto fail;
638 }
639
640 if ((uint8_t *)e != dir_end) {
641 goto broken_dir;
642 }
643
644 g_free(dir);
645 return bm_list;
646
647broken_dir:
648 ret = -EINVAL;
649 error_setg(errp, "Broken bitmap directory");
650
651fail:
652 g_free(dir);
653 bitmap_list_free(bm_list);
654
655 return NULL;
656}
657
658int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
659 void **refcount_table,
660 int64_t *refcount_table_size)
661{
662 int ret;
663 BDRVQcow2State *s = bs->opaque;
664 Qcow2BitmapList *bm_list;
665 Qcow2Bitmap *bm;
666
667 if (s->nb_bitmaps == 0) {
668 return 0;
669 }
670
671 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,
672 s->bitmap_directory_offset,
673 s->bitmap_directory_size);
674 if (ret < 0) {
675 return ret;
676 }
677
678 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
679 s->bitmap_directory_size, NULL);
680 if (bm_list == NULL) {
681 res->corruptions++;
682 return -EINVAL;
683 }
684
685 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
686 uint64_t *bitmap_table = NULL;
687 int i;
688
689 ret = qcow2_inc_refcounts_imrt(bs, res,
690 refcount_table, refcount_table_size,
691 bm->table.offset,
692 bm->table.size * sizeof(uint64_t));
693 if (ret < 0) {
694 goto out;
695 }
696
697 ret = bitmap_table_load(bs, &bm->table, &bitmap_table);
698 if (ret < 0) {
699 res->corruptions++;
700 goto out;
701 }
702
703 for (i = 0; i < bm->table.size; ++i) {
704 uint64_t entry = bitmap_table[i];
705 uint64_t offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
706
707 if (check_table_entry(entry, s->cluster_size) < 0) {
708 res->corruptions++;
709 continue;
710 }
711
712 if (offset == 0) {
713 continue;
714 }
715
716 ret = qcow2_inc_refcounts_imrt(bs, res,
717 refcount_table, refcount_table_size,
718 offset, s->cluster_size);
719 if (ret < 0) {
720 g_free(bitmap_table);
721 goto out;
722 }
723 }
724
725 g_free(bitmap_table);
726 }
727
728out:
729 bitmap_list_free(bm_list);
730
731 return ret;
732}
733
734
735
736
737
738static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list,
739 uint64_t *offset, uint64_t *size, bool in_place)
740{
741 int ret;
742 uint8_t *dir;
743 int64_t dir_offset = 0;
744 uint64_t dir_size = 0;
745 Qcow2Bitmap *bm;
746 Qcow2BitmapDirEntry *e;
747
748 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
749 dir_size += calc_dir_entry_size(strlen(bm->name), 0);
750 }
751
752 if (dir_size == 0 || dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
753 return -EINVAL;
754 }
755
756 if (in_place) {
757 if (*size != dir_size || *offset == 0) {
758 return -EINVAL;
759 }
760
761 dir_offset = *offset;
762 }
763
764 dir = g_try_malloc0(dir_size);
765 if (dir == NULL) {
766 return -ENOMEM;
767 }
768
769 e = (Qcow2BitmapDirEntry *)dir;
770 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
771 e->bitmap_table_offset = bm->table.offset;
772 e->bitmap_table_size = bm->table.size;
773 e->flags = bm->flags;
774 e->type = BT_DIRTY_TRACKING_BITMAP;
775 e->granularity_bits = bm->granularity_bits;
776 e->name_size = strlen(bm->name);
777 e->extra_data_size = 0;
778 memcpy(e + 1, bm->name, e->name_size);
779
780 if (check_dir_entry(bs, e) < 0) {
781 ret = -EINVAL;
782 goto fail;
783 }
784
785 e = next_dir_entry(e);
786 }
787
788 bitmap_directory_to_be(dir, dir_size);
789
790 if (!in_place) {
791 dir_offset = qcow2_alloc_clusters(bs, dir_size);
792 if (dir_offset < 0) {
793 ret = dir_offset;
794 goto fail;
795 }
796 }
797
798
799
800
801
802 ret = qcow2_pre_write_overlap_check(
803 bs, in_place ? QCOW2_OL_BITMAP_DIRECTORY : 0, dir_offset, dir_size,
804 false);
805 if (ret < 0) {
806 goto fail;
807 }
808
809 ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size);
810 if (ret < 0) {
811 goto fail;
812 }
813
814 g_free(dir);
815
816 if (!in_place) {
817 *size = dir_size;
818 *offset = dir_offset;
819 }
820
821 return 0;
822
823fail:
824 g_free(dir);
825
826 if (!in_place && dir_offset > 0) {
827 qcow2_free_clusters(bs, dir_offset, dir_size, QCOW2_DISCARD_OTHER);
828 }
829
830 return ret;
831}
832
833
834
835
836
837static int update_ext_header_and_dir_in_place(BlockDriverState *bs,
838 Qcow2BitmapList *bm_list)
839{
840 BDRVQcow2State *s = bs->opaque;
841 int ret;
842
843 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS) ||
844 bm_list == NULL || QSIMPLEQ_EMPTY(bm_list) ||
845 bitmap_list_count(bm_list) != s->nb_bitmaps)
846 {
847 return -EINVAL;
848 }
849
850 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
851 ret = update_header_sync(bs);
852 if (ret < 0) {
853
854
855
856
857 return ret;
858 }
859
860
861
862 ret = bitmap_list_store(bs, bm_list, &s->bitmap_directory_offset,
863 &s->bitmap_directory_size, true);
864 if (ret < 0) {
865
866
867 return ret;
868 }
869
870 ret = update_header_sync(bs);
871 if (ret < 0) {
872
873
874 return ret;
875 }
876
877 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
878 return update_header_sync(bs);
879
880
881
882
883}
884
885static int update_ext_header_and_dir(BlockDriverState *bs,
886 Qcow2BitmapList *bm_list)
887{
888 BDRVQcow2State *s = bs->opaque;
889 int ret;
890 uint64_t new_offset = 0;
891 uint64_t new_size = 0;
892 uint32_t new_nb_bitmaps = 0;
893 uint64_t old_offset = s->bitmap_directory_offset;
894 uint64_t old_size = s->bitmap_directory_size;
895 uint32_t old_nb_bitmaps = s->nb_bitmaps;
896 uint64_t old_autocl = s->autoclear_features;
897
898 if (bm_list != NULL && !QSIMPLEQ_EMPTY(bm_list)) {
899 new_nb_bitmaps = bitmap_list_count(bm_list);
900
901 if (new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
902 return -EINVAL;
903 }
904
905 ret = bitmap_list_store(bs, bm_list, &new_offset, &new_size, false);
906 if (ret < 0) {
907 return ret;
908 }
909
910 ret = qcow2_flush_caches(bs);
911 if (ret < 0) {
912 goto fail;
913 }
914
915 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
916 } else {
917 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
918 }
919
920 s->bitmap_directory_offset = new_offset;
921 s->bitmap_directory_size = new_size;
922 s->nb_bitmaps = new_nb_bitmaps;
923
924 ret = update_header_sync(bs);
925 if (ret < 0) {
926 goto fail;
927 }
928
929 if (old_size > 0) {
930 qcow2_free_clusters(bs, old_offset, old_size, QCOW2_DISCARD_OTHER);
931 }
932
933 return 0;
934
935fail:
936 if (new_offset > 0) {
937 qcow2_free_clusters(bs, new_offset, new_size, QCOW2_DISCARD_OTHER);
938 }
939
940 s->bitmap_directory_offset = old_offset;
941 s->bitmap_directory_size = old_size;
942 s->nb_bitmaps = old_nb_bitmaps;
943 s->autoclear_features = old_autocl;
944
945 return ret;
946}
947
948
949static void release_dirty_bitmap_helper(gpointer bitmap,
950 gpointer bs)
951{
952 bdrv_release_dirty_bitmap(bs, bitmap);
953}
954
955
956static void set_readonly_helper(gpointer bitmap, gpointer value)
957{
958 bdrv_dirty_bitmap_set_readonly(bitmap, (bool)value);
959}
960
961
962
963
964
965
966
967
968bool qcow2_load_dirty_bitmaps(BlockDriverState *bs, Error **errp)
969{
970 BDRVQcow2State *s = bs->opaque;
971 Qcow2BitmapList *bm_list;
972 Qcow2Bitmap *bm;
973 GSList *created_dirty_bitmaps = NULL;
974 bool header_updated = false;
975 bool needs_update = false;
976
977 if (s->nb_bitmaps == 0) {
978
979 return false;
980 }
981
982 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
983 s->bitmap_directory_size, errp);
984 if (bm_list == NULL) {
985 return false;
986 }
987
988 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
989 BdrvDirtyBitmap *bitmap = load_bitmap(bs, bm, errp);
990 if (bitmap == NULL) {
991 goto fail;
992 }
993
994 bdrv_dirty_bitmap_set_persistence(bitmap, true);
995 if (bm->flags & BME_FLAG_IN_USE) {
996 bdrv_dirty_bitmap_set_inconsistent(bitmap);
997 } else {
998
999 bm->flags |= BME_FLAG_IN_USE;
1000 needs_update = true;
1001 }
1002 if (!(bm->flags & BME_FLAG_AUTO)) {
1003 bdrv_disable_dirty_bitmap(bitmap);
1004 }
1005 created_dirty_bitmaps =
1006 g_slist_append(created_dirty_bitmaps, bitmap);
1007 }
1008
1009 if (needs_update && can_write(bs)) {
1010
1011 int ret = update_ext_header_and_dir_in_place(bs, bm_list);
1012 if (ret < 0) {
1013 error_setg_errno(errp, -ret, "Can't update bitmap directory");
1014 goto fail;
1015 }
1016 header_updated = true;
1017 }
1018
1019 if (!can_write(bs)) {
1020 g_slist_foreach(created_dirty_bitmaps, set_readonly_helper,
1021 (gpointer)true);
1022 }
1023
1024 g_slist_free(created_dirty_bitmaps);
1025 bitmap_list_free(bm_list);
1026
1027 return header_updated;
1028
1029fail:
1030 g_slist_foreach(created_dirty_bitmaps, release_dirty_bitmap_helper, bs);
1031 g_slist_free(created_dirty_bitmaps);
1032 bitmap_list_free(bm_list);
1033
1034 return false;
1035}
1036
1037
1038static Qcow2BitmapInfoFlagsList *get_bitmap_info_flags(uint32_t flags)
1039{
1040 Qcow2BitmapInfoFlagsList *list = NULL;
1041 Qcow2BitmapInfoFlagsList **plist = &list;
1042 int i;
1043
1044 static const struct {
1045 int bme;
1046 int info;
1047 } map[] = {
1048 { BME_FLAG_IN_USE, QCOW2_BITMAP_INFO_FLAGS_IN_USE },
1049 { BME_FLAG_AUTO, QCOW2_BITMAP_INFO_FLAGS_AUTO },
1050 };
1051
1052 int map_size = ARRAY_SIZE(map);
1053
1054 for (i = 0; i < map_size; ++i) {
1055 if (flags & map[i].bme) {
1056 Qcow2BitmapInfoFlagsList *entry =
1057 g_new0(Qcow2BitmapInfoFlagsList, 1);
1058 entry->value = map[i].info;
1059 *plist = entry;
1060 plist = &entry->next;
1061 flags &= ~map[i].bme;
1062 }
1063 }
1064
1065 assert(!flags);
1066
1067 return list;
1068}
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078Qcow2BitmapInfoList *qcow2_get_bitmap_info_list(BlockDriverState *bs,
1079 Error **errp)
1080{
1081 BDRVQcow2State *s = bs->opaque;
1082 Qcow2BitmapList *bm_list;
1083 Qcow2Bitmap *bm;
1084 Qcow2BitmapInfoList *list = NULL;
1085 Qcow2BitmapInfoList **plist = &list;
1086
1087 if (s->nb_bitmaps == 0) {
1088 return NULL;
1089 }
1090
1091 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1092 s->bitmap_directory_size, errp);
1093 if (bm_list == NULL) {
1094 return NULL;
1095 }
1096
1097 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1098 Qcow2BitmapInfo *info = g_new0(Qcow2BitmapInfo, 1);
1099 Qcow2BitmapInfoList *obj = g_new0(Qcow2BitmapInfoList, 1);
1100 info->granularity = 1U << bm->granularity_bits;
1101 info->name = g_strdup(bm->name);
1102 info->flags = get_bitmap_info_flags(bm->flags & ~BME_RESERVED_FLAGS);
1103 obj->value = info;
1104 *plist = obj;
1105 plist = &obj->next;
1106 }
1107
1108 bitmap_list_free(bm_list);
1109
1110 return list;
1111}
1112
1113int qcow2_reopen_bitmaps_rw_hint(BlockDriverState *bs, bool *header_updated,
1114 Error **errp)
1115{
1116 BDRVQcow2State *s = bs->opaque;
1117 Qcow2BitmapList *bm_list;
1118 Qcow2Bitmap *bm;
1119 GSList *ro_dirty_bitmaps = NULL;
1120 int ret = 0;
1121
1122 if (header_updated != NULL) {
1123 *header_updated = false;
1124 }
1125
1126 if (s->nb_bitmaps == 0) {
1127
1128 return 0;
1129 }
1130
1131 if (!can_write(bs)) {
1132 error_setg(errp, "Can't write to the image on reopening bitmaps rw");
1133 return -EINVAL;
1134 }
1135
1136 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1137 s->bitmap_directory_size, errp);
1138 if (bm_list == NULL) {
1139 return -EINVAL;
1140 }
1141
1142 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1143 BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name);
1144 if (bitmap == NULL) {
1145 continue;
1146 }
1147
1148 if (!bdrv_dirty_bitmap_readonly(bitmap)) {
1149 error_setg(errp, "Bitmap %s was loaded prior to rw-reopen, but was "
1150 "not marked as readonly. This is a bug, something went "
1151 "wrong. All of the bitmaps may be corrupted", bm->name);
1152 ret = -EINVAL;
1153 goto out;
1154 }
1155
1156 bm->flags |= BME_FLAG_IN_USE;
1157 ro_dirty_bitmaps = g_slist_append(ro_dirty_bitmaps, bitmap);
1158 }
1159
1160 if (ro_dirty_bitmaps != NULL) {
1161
1162 ret = update_ext_header_and_dir_in_place(bs, bm_list);
1163 if (ret < 0) {
1164 error_setg_errno(errp, -ret, "Can't update bitmap directory");
1165 goto out;
1166 }
1167 if (header_updated != NULL) {
1168 *header_updated = true;
1169 }
1170 g_slist_foreach(ro_dirty_bitmaps, set_readonly_helper, false);
1171 }
1172
1173out:
1174 g_slist_free(ro_dirty_bitmaps);
1175 bitmap_list_free(bm_list);
1176
1177 return ret;
1178}
1179
1180int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp)
1181{
1182 return qcow2_reopen_bitmaps_rw_hint(bs, NULL, errp);
1183}
1184
1185
1186int qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp)
1187{
1188 BDRVQcow2State *s = bs->opaque;
1189 Qcow2BitmapList *bm_list;
1190 Qcow2Bitmap *bm;
1191 int ret = 0;
1192
1193 if (s->nb_bitmaps == 0) {
1194 return 0;
1195 }
1196
1197 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1198 s->bitmap_directory_size, errp);
1199 if (bm_list == NULL) {
1200 return -EINVAL;
1201 }
1202
1203 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1204 BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name);
1205 if (bitmap == NULL) {
1206
1207
1208
1209
1210 error_setg(errp, "Cannot resize qcow2 with persistent bitmaps that "
1211 "were not loaded into memory");
1212 ret = -ENOTSUP;
1213 goto out;
1214 }
1215
1216
1217
1218
1219
1220 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
1221 ret = -ENOTSUP;
1222 goto out;
1223 }
1224 }
1225
1226out:
1227 bitmap_list_free(bm_list);
1228 return ret;
1229}
1230
1231
1232
1233
1234static uint64_t *store_bitmap_data(BlockDriverState *bs,
1235 BdrvDirtyBitmap *bitmap,
1236 uint32_t *bitmap_table_size, Error **errp)
1237{
1238 int ret;
1239 BDRVQcow2State *s = bs->opaque;
1240 int64_t offset;
1241 uint64_t limit;
1242 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
1243 const char *bm_name = bdrv_dirty_bitmap_name(bitmap);
1244 uint8_t *buf = NULL;
1245 BdrvDirtyBitmapIter *dbi;
1246 uint64_t *tb;
1247 uint64_t tb_size =
1248 size_to_clusters(s,
1249 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
1250
1251 if (tb_size > BME_MAX_TABLE_SIZE ||
1252 tb_size * s->cluster_size > BME_MAX_PHYS_SIZE)
1253 {
1254 error_setg(errp, "Bitmap '%s' is too big", bm_name);
1255 return NULL;
1256 }
1257
1258 tb = g_try_new0(uint64_t, tb_size);
1259 if (tb == NULL) {
1260 error_setg(errp, "No memory");
1261 return NULL;
1262 }
1263
1264 dbi = bdrv_dirty_iter_new(bitmap);
1265 buf = g_malloc(s->cluster_size);
1266 limit = bytes_covered_by_bitmap_cluster(s, bitmap);
1267 assert(DIV_ROUND_UP(bm_size, limit) == tb_size);
1268
1269 while ((offset = bdrv_dirty_iter_next(dbi)) >= 0) {
1270 uint64_t cluster = offset / limit;
1271 uint64_t end, write_size;
1272 int64_t off;
1273
1274
1275
1276
1277
1278
1279 offset = QEMU_ALIGN_DOWN(offset, limit);
1280 end = MIN(bm_size, offset + limit);
1281 write_size = bdrv_dirty_bitmap_serialization_size(bitmap, offset,
1282 end - offset);
1283 assert(write_size <= s->cluster_size);
1284
1285 off = qcow2_alloc_clusters(bs, s->cluster_size);
1286 if (off < 0) {
1287 error_setg_errno(errp, -off,
1288 "Failed to allocate clusters for bitmap '%s'",
1289 bm_name);
1290 goto fail;
1291 }
1292 tb[cluster] = off;
1293
1294 bdrv_dirty_bitmap_serialize_part(bitmap, buf, offset, end - offset);
1295 if (write_size < s->cluster_size) {
1296 memset(buf + write_size, 0, s->cluster_size - write_size);
1297 }
1298
1299 ret = qcow2_pre_write_overlap_check(bs, 0, off, s->cluster_size, false);
1300 if (ret < 0) {
1301 error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1302 goto fail;
1303 }
1304
1305 ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size);
1306 if (ret < 0) {
1307 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1308 bm_name);
1309 goto fail;
1310 }
1311
1312 if (end >= bm_size) {
1313 break;
1314 }
1315
1316 bdrv_set_dirty_iter(dbi, end);
1317 }
1318
1319 *bitmap_table_size = tb_size;
1320 g_free(buf);
1321 bdrv_dirty_iter_free(dbi);
1322
1323 return tb;
1324
1325fail:
1326 clear_bitmap_table(bs, tb, tb_size);
1327 g_free(buf);
1328 bdrv_dirty_iter_free(dbi);
1329 g_free(tb);
1330
1331 return NULL;
1332}
1333
1334
1335
1336
1337
1338static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
1339{
1340 int ret;
1341 uint64_t *tb;
1342 int64_t tb_offset;
1343 uint32_t tb_size;
1344 BdrvDirtyBitmap *bitmap = bm->dirty_bitmap;
1345 const char *bm_name;
1346
1347 assert(bitmap != NULL);
1348
1349 bm_name = bdrv_dirty_bitmap_name(bitmap);
1350
1351 tb = store_bitmap_data(bs, bitmap, &tb_size, errp);
1352 if (tb == NULL) {
1353 return -EINVAL;
1354 }
1355
1356 assert(tb_size <= BME_MAX_TABLE_SIZE);
1357 tb_offset = qcow2_alloc_clusters(bs, tb_size * sizeof(tb[0]));
1358 if (tb_offset < 0) {
1359 error_setg_errno(errp, -tb_offset,
1360 "Failed to allocate clusters for bitmap '%s'",
1361 bm_name);
1362 ret = tb_offset;
1363 goto fail;
1364 }
1365
1366 ret = qcow2_pre_write_overlap_check(bs, 0, tb_offset,
1367 tb_size * sizeof(tb[0]), false);
1368 if (ret < 0) {
1369 error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1370 goto fail;
1371 }
1372
1373 bitmap_table_to_be(tb, tb_size);
1374 ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]));
1375 if (ret < 0) {
1376 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1377 bm_name);
1378 goto fail;
1379 }
1380
1381 g_free(tb);
1382
1383 bm->table.offset = tb_offset;
1384 bm->table.size = tb_size;
1385
1386 return 0;
1387
1388fail:
1389 clear_bitmap_table(bs, tb, tb_size);
1390
1391 if (tb_offset > 0) {
1392 qcow2_free_clusters(bs, tb_offset, tb_size * sizeof(tb[0]),
1393 QCOW2_DISCARD_OTHER);
1394 }
1395
1396 g_free(tb);
1397
1398 return ret;
1399}
1400
1401static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,
1402 const char *name)
1403{
1404 Qcow2Bitmap *bm;
1405
1406 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1407 if (strcmp(name, bm->name) == 0) {
1408 return bm;
1409 }
1410 }
1411
1412 return NULL;
1413}
1414
1415void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs,
1416 const char *name,
1417 Error **errp)
1418{
1419 int ret;
1420 BDRVQcow2State *s = bs->opaque;
1421 Qcow2Bitmap *bm;
1422 Qcow2BitmapList *bm_list;
1423
1424 if (s->nb_bitmaps == 0) {
1425
1426
1427 return;
1428 }
1429
1430 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1431 s->bitmap_directory_size, errp);
1432 if (bm_list == NULL) {
1433 return;
1434 }
1435
1436 bm = find_bitmap_by_name(bm_list, name);
1437 if (bm == NULL) {
1438 goto fail;
1439 }
1440
1441 QSIMPLEQ_REMOVE(bm_list, bm, Qcow2Bitmap, entry);
1442
1443 ret = update_ext_header_and_dir(bs, bm_list);
1444 if (ret < 0) {
1445 error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1446 goto fail;
1447 }
1448
1449 free_bitmap_clusters(bs, &bm->table);
1450
1451fail:
1452 bitmap_free(bm);
1453 bitmap_list_free(bm_list);
1454}
1455
1456void qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, Error **errp)
1457{
1458 BdrvDirtyBitmap *bitmap;
1459 BDRVQcow2State *s = bs->opaque;
1460 uint32_t new_nb_bitmaps = s->nb_bitmaps;
1461 uint64_t new_dir_size = s->bitmap_directory_size;
1462 int ret;
1463 Qcow2BitmapList *bm_list;
1464 Qcow2Bitmap *bm;
1465 QSIMPLEQ_HEAD(, Qcow2BitmapTable) drop_tables;
1466 Qcow2BitmapTable *tb, *tb_next;
1467
1468 if (!bdrv_has_changed_persistent_bitmaps(bs)) {
1469
1470 return;
1471 }
1472
1473 if (!can_write(bs)) {
1474 error_setg(errp, "No write access");
1475 return;
1476 }
1477
1478 QSIMPLEQ_INIT(&drop_tables);
1479
1480 if (s->nb_bitmaps == 0) {
1481 bm_list = bitmap_list_new();
1482 } else {
1483 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1484 s->bitmap_directory_size, errp);
1485 if (bm_list == NULL) {
1486 return;
1487 }
1488 }
1489
1490
1491 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL;
1492 bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
1493 {
1494 const char *name = bdrv_dirty_bitmap_name(bitmap);
1495 uint32_t granularity = bdrv_dirty_bitmap_granularity(bitmap);
1496 Qcow2Bitmap *bm;
1497
1498 if (!bdrv_dirty_bitmap_get_persistence(bitmap) ||
1499 bdrv_dirty_bitmap_readonly(bitmap) ||
1500 bdrv_dirty_bitmap_inconsistent(bitmap)) {
1501 continue;
1502 }
1503
1504 if (check_constraints_on_bitmap(bs, name, granularity, errp) < 0) {
1505 error_prepend(errp, "Bitmap '%s' doesn't satisfy the constraints: ",
1506 name);
1507 goto fail;
1508 }
1509
1510 bm = find_bitmap_by_name(bm_list, name);
1511 if (bm == NULL) {
1512 if (++new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
1513 error_setg(errp, "Too many persistent bitmaps");
1514 goto fail;
1515 }
1516
1517 new_dir_size += calc_dir_entry_size(strlen(name), 0);
1518 if (new_dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
1519 error_setg(errp, "Bitmap directory is too large");
1520 goto fail;
1521 }
1522
1523 bm = g_new0(Qcow2Bitmap, 1);
1524 bm->name = g_strdup(name);
1525 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry);
1526 } else {
1527 if (!(bm->flags & BME_FLAG_IN_USE)) {
1528 error_setg(errp, "Bitmap '%s' already exists in the image",
1529 name);
1530 goto fail;
1531 }
1532 tb = g_memdup(&bm->table, sizeof(bm->table));
1533 bm->table.offset = 0;
1534 bm->table.size = 0;
1535 QSIMPLEQ_INSERT_TAIL(&drop_tables, tb, entry);
1536 }
1537 bm->flags = bdrv_dirty_bitmap_enabled(bitmap) ? BME_FLAG_AUTO : 0;
1538 bm->granularity_bits = ctz32(bdrv_dirty_bitmap_granularity(bitmap));
1539 bm->dirty_bitmap = bitmap;
1540 }
1541
1542
1543 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1544 if (bm->dirty_bitmap == NULL) {
1545 continue;
1546 }
1547
1548 ret = store_bitmap(bs, bm, errp);
1549 if (ret < 0) {
1550 goto fail;
1551 }
1552 }
1553
1554 ret = update_ext_header_and_dir(bs, bm_list);
1555 if (ret < 0) {
1556 error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1557 goto fail;
1558 }
1559
1560
1561
1562 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1563 free_bitmap_clusters(bs, tb);
1564 g_free(tb);
1565 }
1566
1567 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1568
1569
1570
1571
1572
1573
1574
1575
1576 if (bm->dirty_bitmap == NULL) {
1577 continue;
1578 }
1579
1580 bdrv_release_dirty_bitmap(bs, bm->dirty_bitmap);
1581 }
1582
1583 bitmap_list_free(bm_list);
1584 return;
1585
1586fail:
1587 QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1588 if (bm->dirty_bitmap == NULL || bm->table.offset == 0) {
1589 continue;
1590 }
1591
1592 free_bitmap_clusters(bs, &bm->table);
1593 }
1594
1595 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1596 g_free(tb);
1597 }
1598
1599 bitmap_list_free(bm_list);
1600}
1601
1602int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp)
1603{
1604 BdrvDirtyBitmap *bitmap;
1605 Error *local_err = NULL;
1606
1607 qcow2_store_persistent_dirty_bitmaps(bs, &local_err);
1608 if (local_err != NULL) {
1609 error_propagate(errp, local_err);
1610 return -EINVAL;
1611 }
1612
1613 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL;
1614 bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
1615 {
1616 if (bdrv_dirty_bitmap_get_persistence(bitmap)) {
1617 bdrv_dirty_bitmap_set_readonly(bitmap, true);
1618 }
1619 }
1620
1621 return 0;
1622}
1623
1624bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,
1625 const char *name,
1626 uint32_t granularity,
1627 Error **errp)
1628{
1629 BDRVQcow2State *s = bs->opaque;
1630 bool found;
1631 Qcow2BitmapList *bm_list;
1632
1633 if (s->qcow_version < 3) {
1634
1635
1636
1637
1638
1639 error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files");
1640 goto fail;
1641 }
1642
1643 if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) {
1644 goto fail;
1645 }
1646
1647 if (s->nb_bitmaps == 0) {
1648 return true;
1649 }
1650
1651 if (s->nb_bitmaps >= QCOW2_MAX_BITMAPS) {
1652 error_setg(errp,
1653 "Maximum number of persistent bitmaps is already reached");
1654 goto fail;
1655 }
1656
1657 if (s->bitmap_directory_size + calc_dir_entry_size(strlen(name), 0) >
1658 QCOW2_MAX_BITMAP_DIRECTORY_SIZE)
1659 {
1660 error_setg(errp, "Not enough space in the bitmap directory");
1661 goto fail;
1662 }
1663
1664 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1665 s->bitmap_directory_size, errp);
1666 if (bm_list == NULL) {
1667 goto fail;
1668 }
1669
1670 found = find_bitmap_by_name(bm_list, name);
1671 bitmap_list_free(bm_list);
1672 if (found) {
1673 error_setg(errp, "Bitmap with the same name is already stored");
1674 goto fail;
1675 }
1676
1677 return true;
1678
1679fail:
1680 error_prepend(errp, "Can't make bitmap '%s' persistent in '%s': ",
1681 name, bdrv_get_device_or_node_name(bs));
1682 return false;
1683}
1684