1 /* 2 * Bitmaps for the QCOW version 2 format 3 * 4 * Copyright (c) 2014-2017 Vladimir Sementsov-Ogievskiy 5 * 6 * This file is derived from qcow2-snapshot.c, original copyright: 7 * Copyright (c) 2004-2006 Fabrice Bellard 8 * 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: 15 * 16 * The above copyright notice and this permission notice shall be included in 17 * all copies or substantial portions of the Software. 18 * 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. 26 */ 27 28 #include "qemu/osdep.h" 29 #include "qapi/error.h" 30 #include "qemu/cutils.h" 31 32 #include "block/block_int.h" 33 #include "block/qcow2.h" 34 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. */ 38 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 45 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 49 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) 54 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) 59 60 typedef struct QEMU_PACKED Qcow2BitmapDirEntry { 61 /* header is 8 byte aligned */ 62 uint64_t bitmap_table_offset; 63 64 uint32_t bitmap_table_size; 65 uint32_t flags; 66 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; 74 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; 82 83 typedef struct Qcow2Bitmap { 84 Qcow2BitmapTable table; 85 uint32_t flags; 86 uint8_t granularity_bits; 87 char *name; 88 89 BdrvDirtyBitmap *dirty_bitmap; 90 91 QSIMPLEQ_ENTRY(Qcow2Bitmap) entry; 92 } Qcow2Bitmap; 93 typedef QSIMPLEQ_HEAD(Qcow2BitmapList, Qcow2Bitmap) Qcow2BitmapList; 94 95 typedef enum BitmapType { 96 BT_DIRTY_TRACKING_BITMAP = 1 97 } BitmapType; 98 99 static inline bool can_write(BlockDriverState *bs) 100 { 101 return !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE); 102 } 103 104 static int update_header_sync(BlockDriverState *bs) 105 { 106 int ret; 107 108 ret = qcow2_update_header(bs); 109 if (ret < 0) { 110 return ret; 111 } 112 113 return bdrv_flush(bs); 114 } 115 116 static inline void bitmap_table_to_be(uint64_t *bitmap_table, size_t size) 117 { 118 size_t i; 119 120 for (i = 0; i < size; ++i) { 121 cpu_to_be64s(&bitmap_table[i]); 122 } 123 } 124 125 static int check_table_entry(uint64_t entry, int cluster_size) 126 { 127 uint64_t offset; 128 129 if (entry & BME_TABLE_ENTRY_RESERVED_MASK) { 130 return -EINVAL; 131 } 132 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; 138 } 139 140 if (offset % cluster_size != 0) { 141 return -EINVAL; 142 } 143 } 144 145 return 0; 146 } 147 148 static int check_constraints_on_bitmap(BlockDriverState *bs, 149 const char *name, 150 uint32_t granularity, 151 Error **errp) 152 { 153 BDRVQcow2State *s = bs->opaque; 154 int granularity_bits = ctz32(granularity); 155 int64_t len = bdrv_getlength(bs); 156 157 assert(granularity > 0); 158 assert((granularity & (granularity - 1)) == 0); 159 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; 164 } 165 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; 170 } 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; 175 } 176 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)) 180 { 181 error_setg(errp, "Too much space will be occupied by the bitmap. " 182 "Use larger granularity"); 183 return -EINVAL; 184 } 185 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; 190 } 191 192 return 0; 193 } 194 195 static void clear_bitmap_table(BlockDriverState *bs, uint64_t *bitmap_table, 196 uint32_t bitmap_table_size) 197 { 198 BDRVQcow2State *s = bs->opaque; 199 int i; 200 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; 205 } 206 207 qcow2_free_clusters(bs, addr, s->cluster_size, QCOW2_DISCARD_OTHER); 208 bitmap_table[i] = 0; 209 } 210 } 211 212 static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb, 213 uint64_t **bitmap_table) 214 { 215 int ret; 216 BDRVQcow2State *s = bs->opaque; 217 uint32_t i; 218 uint64_t *table; 219 220 assert(tb->size != 0); 221 table = g_try_new(uint64_t, tb->size); 222 if (table == NULL) { 223 return -ENOMEM; 224 } 225 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; 231 } 232 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; 238 } 239 } 240 241 *bitmap_table = table; 242 return 0; 243 244 fail: 245 g_free(table); 246 247 return ret; 248 } 249 250 static int free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb) 251 { 252 int ret; 253 uint64_t *bitmap_table; 254 255 ret = bitmap_table_load(bs, tb, &bitmap_table); 256 if (ret < 0) { 257 assert(bitmap_table == NULL); 258 return ret; 259 } 260 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); 265 266 tb->offset = 0; 267 tb->size = 0; 268 269 return 0; 270 } 271 272 /* This function returns the number of disk sectors covered by a single qcow2 273 * cluster of bitmap data. */ 274 static uint64_t sectors_covered_by_bitmap_cluster(const BDRVQcow2State *s, 275 const BdrvDirtyBitmap *bitmap) 276 { 277 uint32_t sector_granularity = 278 bdrv_dirty_bitmap_granularity(bitmap) >> BDRV_SECTOR_BITS; 279 280 return (uint64_t)sector_granularity * (s->cluster_size << 3); 281 } 282 283 /* load_bitmap_data 284 * @bitmap_table entries must satisfy specification constraints. 285 * @bitmap must be cleared */ 286 static int load_bitmap_data(BlockDriverState *bs, 287 const uint64_t *bitmap_table, 288 uint32_t bitmap_table_size, 289 BdrvDirtyBitmap *bitmap) 290 { 291 int ret = 0; 292 BDRVQcow2State *s = bs->opaque; 293 uint64_t sector, sbc; 294 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap); 295 uint8_t *buf = NULL; 296 uint64_t i, tab_size = 297 size_to_clusters(s, 298 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size)); 299 300 if (tab_size != bitmap_table_size || tab_size > BME_MAX_TABLE_SIZE) { 301 return -EINVAL; 302 } 303 304 buf = g_malloc(s->cluster_size); 305 sbc = sectors_covered_by_bitmap_cluster(s, bitmap); 306 for (i = 0, sector = 0; i < tab_size; ++i, sector += sbc) { 307 uint64_t count = MIN(bm_size - sector, sbc); 308 uint64_t entry = bitmap_table[i]; 309 uint64_t offset = entry & BME_TABLE_ENTRY_OFFSET_MASK; 310 311 assert(check_table_entry(entry, s->cluster_size) == 0); 312 313 if (offset == 0) { 314 if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) { 315 bdrv_dirty_bitmap_deserialize_ones(bitmap, sector, count, 316 false); 317 } else { 318 /* No need to deserialize zeros because the dirty bitmap is 319 * already cleared */ 320 } 321 } else { 322 ret = bdrv_pread(bs->file, offset, buf, s->cluster_size); 323 if (ret < 0) { 324 goto finish; 325 } 326 bdrv_dirty_bitmap_deserialize_part(bitmap, buf, sector, count, 327 false); 328 } 329 } 330 ret = 0; 331 332 bdrv_dirty_bitmap_deserialize_finish(bitmap); 333 334 finish: 335 g_free(buf); 336 337 return ret; 338 } 339 340 static BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs, 341 Qcow2Bitmap *bm, Error **errp) 342 { 343 int ret; 344 uint64_t *bitmap_table = NULL; 345 uint32_t granularity; 346 BdrvDirtyBitmap *bitmap = NULL; 347 348 if (bm->flags & BME_FLAG_IN_USE) { 349 error_setg(errp, "Bitmap '%s' is in use", bm->name); 350 goto fail; 351 } 352 353 ret = bitmap_table_load(bs, &bm->table, &bitmap_table); 354 if (ret < 0) { 355 error_setg_errno(errp, -ret, 356 "Could not read bitmap_table table from image for " 357 "bitmap '%s'", bm->name); 358 goto fail; 359 } 360 361 granularity = 1U << bm->granularity_bits; 362 bitmap = bdrv_create_dirty_bitmap(bs, granularity, bm->name, errp); 363 if (bitmap == NULL) { 364 goto fail; 365 } 366 367 ret = load_bitmap_data(bs, bitmap_table, bm->table.size, bitmap); 368 if (ret < 0) { 369 error_setg_errno(errp, -ret, "Could not read bitmap '%s' from image", 370 bm->name); 371 goto fail; 372 } 373 374 g_free(bitmap_table); 375 return bitmap; 376 377 fail: 378 g_free(bitmap_table); 379 if (bitmap != NULL) { 380 bdrv_release_dirty_bitmap(bs, bitmap); 381 } 382 383 return NULL; 384 } 385 386 /* 387 * Bitmap List 388 */ 389 390 /* 391 * Bitmap List private functions 392 * Only Bitmap List knows about bitmap directory structure in Qcow2. 393 */ 394 395 static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry *entry) 396 { 397 be64_to_cpus(&entry->bitmap_table_offset); 398 be32_to_cpus(&entry->bitmap_table_size); 399 be32_to_cpus(&entry->flags); 400 be16_to_cpus(&entry->name_size); 401 be32_to_cpus(&entry->extra_data_size); 402 } 403 404 static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry) 405 { 406 cpu_to_be64s(&entry->bitmap_table_offset); 407 cpu_to_be32s(&entry->bitmap_table_size); 408 cpu_to_be32s(&entry->flags); 409 cpu_to_be16s(&entry->name_size); 410 cpu_to_be32s(&entry->extra_data_size); 411 } 412 413 static inline int calc_dir_entry_size(size_t name_size, size_t extra_data_size) 414 { 415 return align_offset(sizeof(Qcow2BitmapDirEntry) + 416 name_size + extra_data_size, 8); 417 } 418 419 static inline int dir_entry_size(Qcow2BitmapDirEntry *entry) 420 { 421 return calc_dir_entry_size(entry->name_size, entry->extra_data_size); 422 } 423 424 static inline const char *dir_entry_name_field(Qcow2BitmapDirEntry *entry) 425 { 426 return (const char *)(entry + 1) + entry->extra_data_size; 427 } 428 429 static inline char *dir_entry_copy_name(Qcow2BitmapDirEntry *entry) 430 { 431 const char *name_field = dir_entry_name_field(entry); 432 return g_strndup(name_field, entry->name_size); 433 } 434 435 static inline Qcow2BitmapDirEntry *next_dir_entry(Qcow2BitmapDirEntry *entry) 436 { 437 return (Qcow2BitmapDirEntry *)((uint8_t *)entry + dir_entry_size(entry)); 438 } 439 440 static int check_dir_entry(BlockDriverState *bs, Qcow2BitmapDirEntry *entry) 441 { 442 BDRVQcow2State *s = bs->opaque; 443 uint64_t phys_bitmap_bytes; 444 int64_t len; 445 446 bool fail = (entry->bitmap_table_size == 0) || 447 (entry->bitmap_table_offset == 0) || 448 (entry->bitmap_table_offset % s->cluster_size) || 449 (entry->bitmap_table_size > BME_MAX_TABLE_SIZE) || 450 (entry->granularity_bits > BME_MAX_GRANULARITY_BITS) || 451 (entry->granularity_bits < BME_MIN_GRANULARITY_BITS) || 452 (entry->flags & BME_RESERVED_FLAGS) || 453 (entry->name_size > BME_MAX_NAME_SIZE) || 454 (entry->type != BT_DIRTY_TRACKING_BITMAP); 455 456 if (fail) { 457 return -EINVAL; 458 } 459 460 phys_bitmap_bytes = (uint64_t)entry->bitmap_table_size * s->cluster_size; 461 len = bdrv_getlength(bs); 462 463 if (len < 0) { 464 return len; 465 } 466 467 fail = (phys_bitmap_bytes > BME_MAX_PHYS_SIZE) || 468 (len > ((phys_bitmap_bytes * 8) << entry->granularity_bits)); 469 470 return fail ? -EINVAL : 0; 471 } 472 473 static inline void bitmap_directory_to_be(uint8_t *dir, size_t size) 474 { 475 uint8_t *end = dir + size; 476 while (dir < end) { 477 Qcow2BitmapDirEntry *e = (Qcow2BitmapDirEntry *)dir; 478 dir += dir_entry_size(e); 479 480 bitmap_dir_entry_to_be(e); 481 } 482 } 483 484 /* 485 * Bitmap List public functions 486 */ 487 488 static void bitmap_free(Qcow2Bitmap *bm) 489 { 490 g_free(bm->name); 491 g_free(bm); 492 } 493 494 static void bitmap_list_free(Qcow2BitmapList *bm_list) 495 { 496 Qcow2Bitmap *bm; 497 498 if (bm_list == NULL) { 499 return; 500 } 501 502 while ((bm = QSIMPLEQ_FIRST(bm_list)) != NULL) { 503 QSIMPLEQ_REMOVE_HEAD(bm_list, entry); 504 bitmap_free(bm); 505 } 506 507 g_free(bm_list); 508 } 509 510 static Qcow2BitmapList *bitmap_list_new(void) 511 { 512 Qcow2BitmapList *bm_list = g_new(Qcow2BitmapList, 1); 513 QSIMPLEQ_INIT(bm_list); 514 515 return bm_list; 516 } 517 518 static uint32_t bitmap_list_count(Qcow2BitmapList *bm_list) 519 { 520 Qcow2Bitmap *bm; 521 uint32_t nb_bitmaps = 0; 522 523 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 524 nb_bitmaps++; 525 } 526 527 return nb_bitmaps; 528 } 529 530 /* bitmap_list_load 531 * Get bitmap list from qcow2 image. Actually reads bitmap directory, 532 * checks it and convert to bitmap list. 533 */ 534 static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset, 535 uint64_t size, Error **errp) 536 { 537 int ret; 538 BDRVQcow2State *s = bs->opaque; 539 uint8_t *dir, *dir_end; 540 Qcow2BitmapDirEntry *e; 541 uint32_t nb_dir_entries = 0; 542 Qcow2BitmapList *bm_list = NULL; 543 544 if (size == 0) { 545 error_setg(errp, "Requested bitmap directory size is zero"); 546 return NULL; 547 } 548 549 if (size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 550 error_setg(errp, "Requested bitmap directory size is too big"); 551 return NULL; 552 } 553 554 dir = g_try_malloc(size); 555 if (dir == NULL) { 556 error_setg(errp, "Failed to allocate space for bitmap directory"); 557 return NULL; 558 } 559 dir_end = dir + size; 560 561 ret = bdrv_pread(bs->file, offset, dir, size); 562 if (ret < 0) { 563 error_setg_errno(errp, -ret, "Failed to read bitmap directory"); 564 goto fail; 565 } 566 567 bm_list = bitmap_list_new(); 568 for (e = (Qcow2BitmapDirEntry *)dir; 569 e < (Qcow2BitmapDirEntry *)dir_end; 570 e = next_dir_entry(e)) 571 { 572 Qcow2Bitmap *bm; 573 574 if ((uint8_t *)(e + 1) > dir_end) { 575 goto broken_dir; 576 } 577 578 if (++nb_dir_entries > s->nb_bitmaps) { 579 error_setg(errp, "More bitmaps found than specified in header" 580 " extension"); 581 goto fail; 582 } 583 bitmap_dir_entry_to_cpu(e); 584 585 if ((uint8_t *)next_dir_entry(e) > dir_end) { 586 goto broken_dir; 587 } 588 589 if (e->extra_data_size != 0) { 590 error_setg(errp, "Bitmap extra data is not supported"); 591 goto fail; 592 } 593 594 ret = check_dir_entry(bs, e); 595 if (ret < 0) { 596 error_setg(errp, "Bitmap '%.*s' doesn't satisfy the constraints", 597 e->name_size, dir_entry_name_field(e)); 598 goto fail; 599 } 600 601 bm = g_new(Qcow2Bitmap, 1); 602 bm->table.offset = e->bitmap_table_offset; 603 bm->table.size = e->bitmap_table_size; 604 bm->flags = e->flags; 605 bm->granularity_bits = e->granularity_bits; 606 bm->name = dir_entry_copy_name(e); 607 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry); 608 } 609 610 if (nb_dir_entries != s->nb_bitmaps) { 611 error_setg(errp, "Less bitmaps found than specified in header" 612 " extension"); 613 goto fail; 614 } 615 616 if ((uint8_t *)e != dir_end) { 617 goto broken_dir; 618 } 619 620 g_free(dir); 621 return bm_list; 622 623 broken_dir: 624 ret = -EINVAL; 625 error_setg(errp, "Broken bitmap directory"); 626 627 fail: 628 g_free(dir); 629 bitmap_list_free(bm_list); 630 631 return NULL; 632 } 633 634 int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 635 void **refcount_table, 636 int64_t *refcount_table_size) 637 { 638 int ret; 639 BDRVQcow2State *s = bs->opaque; 640 Qcow2BitmapList *bm_list; 641 Qcow2Bitmap *bm; 642 643 if (s->nb_bitmaps == 0) { 644 return 0; 645 } 646 647 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size, 648 s->bitmap_directory_offset, 649 s->bitmap_directory_size); 650 if (ret < 0) { 651 return ret; 652 } 653 654 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 655 s->bitmap_directory_size, NULL); 656 if (bm_list == NULL) { 657 res->corruptions++; 658 return -EINVAL; 659 } 660 661 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 662 uint64_t *bitmap_table = NULL; 663 int i; 664 665 ret = qcow2_inc_refcounts_imrt(bs, res, 666 refcount_table, refcount_table_size, 667 bm->table.offset, 668 bm->table.size * sizeof(uint64_t)); 669 if (ret < 0) { 670 goto out; 671 } 672 673 ret = bitmap_table_load(bs, &bm->table, &bitmap_table); 674 if (ret < 0) { 675 res->corruptions++; 676 goto out; 677 } 678 679 for (i = 0; i < bm->table.size; ++i) { 680 uint64_t entry = bitmap_table[i]; 681 uint64_t offset = entry & BME_TABLE_ENTRY_OFFSET_MASK; 682 683 if (check_table_entry(entry, s->cluster_size) < 0) { 684 res->corruptions++; 685 continue; 686 } 687 688 if (offset == 0) { 689 continue; 690 } 691 692 ret = qcow2_inc_refcounts_imrt(bs, res, 693 refcount_table, refcount_table_size, 694 offset, s->cluster_size); 695 if (ret < 0) { 696 g_free(bitmap_table); 697 goto out; 698 } 699 } 700 701 g_free(bitmap_table); 702 } 703 704 out: 705 bitmap_list_free(bm_list); 706 707 return ret; 708 } 709 710 /* bitmap_list_store 711 * Store bitmap list to qcow2 image as a bitmap directory. 712 * Everything is checked. 713 */ 714 static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list, 715 uint64_t *offset, uint64_t *size, bool in_place) 716 { 717 int ret; 718 uint8_t *dir; 719 int64_t dir_offset = 0; 720 uint64_t dir_size = 0; 721 Qcow2Bitmap *bm; 722 Qcow2BitmapDirEntry *e; 723 724 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 725 dir_size += calc_dir_entry_size(strlen(bm->name), 0); 726 } 727 728 if (dir_size == 0 || dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 729 return -EINVAL; 730 } 731 732 if (in_place) { 733 if (*size != dir_size || *offset == 0) { 734 return -EINVAL; 735 } 736 737 dir_offset = *offset; 738 } 739 740 dir = g_try_malloc(dir_size); 741 if (dir == NULL) { 742 return -ENOMEM; 743 } 744 745 e = (Qcow2BitmapDirEntry *)dir; 746 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 747 e->bitmap_table_offset = bm->table.offset; 748 e->bitmap_table_size = bm->table.size; 749 e->flags = bm->flags; 750 e->type = BT_DIRTY_TRACKING_BITMAP; 751 e->granularity_bits = bm->granularity_bits; 752 e->name_size = strlen(bm->name); 753 e->extra_data_size = 0; 754 memcpy(e + 1, bm->name, e->name_size); 755 756 if (check_dir_entry(bs, e) < 0) { 757 ret = -EINVAL; 758 goto fail; 759 } 760 761 e = next_dir_entry(e); 762 } 763 764 bitmap_directory_to_be(dir, dir_size); 765 766 if (!in_place) { 767 dir_offset = qcow2_alloc_clusters(bs, dir_size); 768 if (dir_offset < 0) { 769 ret = dir_offset; 770 goto fail; 771 } 772 } 773 774 ret = qcow2_pre_write_overlap_check(bs, 0, dir_offset, dir_size); 775 if (ret < 0) { 776 goto fail; 777 } 778 779 ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size); 780 if (ret < 0) { 781 goto fail; 782 } 783 784 g_free(dir); 785 786 if (!in_place) { 787 *size = dir_size; 788 *offset = dir_offset; 789 } 790 791 return 0; 792 793 fail: 794 g_free(dir); 795 796 if (!in_place && dir_offset > 0) { 797 qcow2_free_clusters(bs, dir_offset, dir_size, QCOW2_DISCARD_OTHER); 798 } 799 800 return ret; 801 } 802 803 /* 804 * Bitmap List end 805 */ 806 807 static int update_ext_header_and_dir_in_place(BlockDriverState *bs, 808 Qcow2BitmapList *bm_list) 809 { 810 BDRVQcow2State *s = bs->opaque; 811 int ret; 812 813 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS) || 814 bm_list == NULL || QSIMPLEQ_EMPTY(bm_list) || 815 bitmap_list_count(bm_list) != s->nb_bitmaps) 816 { 817 return -EINVAL; 818 } 819 820 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS; 821 ret = update_header_sync(bs); 822 if (ret < 0) { 823 /* Two variants are possible here: 824 * 1. Autoclear flag is dropped, all bitmaps will be lost. 825 * 2. Autoclear flag is not dropped, old state is left. 826 */ 827 return ret; 828 } 829 830 /* autoclear bit is not set, so we can safely update bitmap directory */ 831 832 ret = bitmap_list_store(bs, bm_list, &s->bitmap_directory_offset, 833 &s->bitmap_directory_size, true); 834 if (ret < 0) { 835 /* autoclear bit is cleared, so all leaked clusters would be removed on 836 * qemu-img check */ 837 return ret; 838 } 839 840 ret = update_header_sync(bs); 841 if (ret < 0) { 842 /* autoclear bit is cleared, so all leaked clusters would be removed on 843 * qemu-img check */ 844 return ret; 845 } 846 847 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS; 848 return update_header_sync(bs); 849 /* If final update_header_sync() fails, two variants are possible: 850 * 1. Autoclear flag is not set, all bitmaps will be lost. 851 * 2. Autoclear flag is set, header and directory are successfully updated. 852 */ 853 } 854 855 static int update_ext_header_and_dir(BlockDriverState *bs, 856 Qcow2BitmapList *bm_list) 857 { 858 BDRVQcow2State *s = bs->opaque; 859 int ret; 860 uint64_t new_offset = 0; 861 uint64_t new_size = 0; 862 uint32_t new_nb_bitmaps = 0; 863 uint64_t old_offset = s->bitmap_directory_offset; 864 uint64_t old_size = s->bitmap_directory_size; 865 uint32_t old_nb_bitmaps = s->nb_bitmaps; 866 uint64_t old_autocl = s->autoclear_features; 867 868 if (bm_list != NULL && !QSIMPLEQ_EMPTY(bm_list)) { 869 new_nb_bitmaps = bitmap_list_count(bm_list); 870 871 if (new_nb_bitmaps > QCOW2_MAX_BITMAPS) { 872 return -EINVAL; 873 } 874 875 ret = bitmap_list_store(bs, bm_list, &new_offset, &new_size, false); 876 if (ret < 0) { 877 return ret; 878 } 879 880 ret = bdrv_flush(bs->file->bs); 881 if (ret < 0) { 882 goto fail; 883 } 884 885 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS; 886 } else { 887 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS; 888 } 889 890 s->bitmap_directory_offset = new_offset; 891 s->bitmap_directory_size = new_size; 892 s->nb_bitmaps = new_nb_bitmaps; 893 894 ret = update_header_sync(bs); 895 if (ret < 0) { 896 goto fail; 897 } 898 899 if (old_size > 0) { 900 qcow2_free_clusters(bs, old_offset, old_size, QCOW2_DISCARD_OTHER); 901 } 902 903 return 0; 904 905 fail: 906 if (new_offset > 0) { 907 qcow2_free_clusters(bs, new_offset, new_size, QCOW2_DISCARD_OTHER); 908 } 909 910 s->bitmap_directory_offset = old_offset; 911 s->bitmap_directory_size = old_size; 912 s->nb_bitmaps = old_nb_bitmaps; 913 s->autoclear_features = old_autocl; 914 915 return ret; 916 } 917 918 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */ 919 static void release_dirty_bitmap_helper(gpointer bitmap, 920 gpointer bs) 921 { 922 bdrv_release_dirty_bitmap(bs, bitmap); 923 } 924 925 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */ 926 static void set_readonly_helper(gpointer bitmap, gpointer value) 927 { 928 bdrv_dirty_bitmap_set_readonly(bitmap, (bool)value); 929 } 930 931 /* qcow2_load_autoloading_dirty_bitmaps() 932 * Return value is a hint for caller: true means that the Qcow2 header was 933 * updated. (false doesn't mean that the header should be updated by the 934 * caller, it just means that updating was not needed or the image cannot be 935 * written to). 936 * On failure the function returns false. 937 */ 938 bool qcow2_load_autoloading_dirty_bitmaps(BlockDriverState *bs, Error **errp) 939 { 940 BDRVQcow2State *s = bs->opaque; 941 Qcow2BitmapList *bm_list; 942 Qcow2Bitmap *bm; 943 GSList *created_dirty_bitmaps = NULL; 944 bool header_updated = false; 945 946 if (s->nb_bitmaps == 0) { 947 /* No bitmaps - nothing to do */ 948 return false; 949 } 950 951 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 952 s->bitmap_directory_size, errp); 953 if (bm_list == NULL) { 954 return false; 955 } 956 957 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 958 if ((bm->flags & BME_FLAG_AUTO) && !(bm->flags & BME_FLAG_IN_USE)) { 959 BdrvDirtyBitmap *bitmap = load_bitmap(bs, bm, errp); 960 if (bitmap == NULL) { 961 goto fail; 962 } 963 964 bdrv_dirty_bitmap_set_persistance(bitmap, true); 965 bdrv_dirty_bitmap_set_autoload(bitmap, true); 966 bm->flags |= BME_FLAG_IN_USE; 967 created_dirty_bitmaps = 968 g_slist_append(created_dirty_bitmaps, bitmap); 969 } 970 } 971 972 if (created_dirty_bitmaps != NULL) { 973 if (can_write(bs)) { 974 /* in_use flags must be updated */ 975 int ret = update_ext_header_and_dir_in_place(bs, bm_list); 976 if (ret < 0) { 977 error_setg_errno(errp, -ret, "Can't update bitmap directory"); 978 goto fail; 979 } 980 header_updated = true; 981 } else { 982 g_slist_foreach(created_dirty_bitmaps, set_readonly_helper, 983 (gpointer)true); 984 } 985 } 986 987 g_slist_free(created_dirty_bitmaps); 988 bitmap_list_free(bm_list); 989 990 return header_updated; 991 992 fail: 993 g_slist_foreach(created_dirty_bitmaps, release_dirty_bitmap_helper, bs); 994 g_slist_free(created_dirty_bitmaps); 995 bitmap_list_free(bm_list); 996 997 return false; 998 } 999 1000 int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp) 1001 { 1002 BDRVQcow2State *s = bs->opaque; 1003 Qcow2BitmapList *bm_list; 1004 Qcow2Bitmap *bm; 1005 GSList *ro_dirty_bitmaps = NULL; 1006 int ret = 0; 1007 1008 if (s->nb_bitmaps == 0) { 1009 /* No bitmaps - nothing to do */ 1010 return 0; 1011 } 1012 1013 if (!can_write(bs)) { 1014 error_setg(errp, "Can't write to the image on reopening bitmaps rw"); 1015 return -EINVAL; 1016 } 1017 1018 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1019 s->bitmap_directory_size, errp); 1020 if (bm_list == NULL) { 1021 return -EINVAL; 1022 } 1023 1024 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1025 if (!(bm->flags & BME_FLAG_IN_USE)) { 1026 BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name); 1027 if (bitmap == NULL) { 1028 continue; 1029 } 1030 1031 if (!bdrv_dirty_bitmap_readonly(bitmap)) { 1032 error_setg(errp, "Bitmap %s is not readonly but not marked" 1033 "'IN_USE' in the image. Something went wrong," 1034 "all the bitmaps may be corrupted", bm->name); 1035 ret = -EINVAL; 1036 goto out; 1037 } 1038 1039 bm->flags |= BME_FLAG_IN_USE; 1040 ro_dirty_bitmaps = g_slist_append(ro_dirty_bitmaps, bitmap); 1041 } 1042 } 1043 1044 if (ro_dirty_bitmaps != NULL) { 1045 /* in_use flags must be updated */ 1046 ret = update_ext_header_and_dir_in_place(bs, bm_list); 1047 if (ret < 0) { 1048 error_setg_errno(errp, -ret, "Can't update bitmap directory"); 1049 goto out; 1050 } 1051 g_slist_foreach(ro_dirty_bitmaps, set_readonly_helper, false); 1052 } 1053 1054 out: 1055 g_slist_free(ro_dirty_bitmaps); 1056 bitmap_list_free(bm_list); 1057 1058 return ret; 1059 } 1060 1061 /* store_bitmap_data() 1062 * Store bitmap to image, filling bitmap table accordingly. 1063 */ 1064 static uint64_t *store_bitmap_data(BlockDriverState *bs, 1065 BdrvDirtyBitmap *bitmap, 1066 uint32_t *bitmap_table_size, Error **errp) 1067 { 1068 int ret; 1069 BDRVQcow2State *s = bs->opaque; 1070 int64_t sector; 1071 uint64_t sbc; 1072 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap); 1073 const char *bm_name = bdrv_dirty_bitmap_name(bitmap); 1074 uint8_t *buf = NULL; 1075 BdrvDirtyBitmapIter *dbi; 1076 uint64_t *tb; 1077 uint64_t tb_size = 1078 size_to_clusters(s, 1079 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size)); 1080 1081 if (tb_size > BME_MAX_TABLE_SIZE || 1082 tb_size * s->cluster_size > BME_MAX_PHYS_SIZE) 1083 { 1084 error_setg(errp, "Bitmap '%s' is too big", bm_name); 1085 return NULL; 1086 } 1087 1088 tb = g_try_new0(uint64_t, tb_size); 1089 if (tb == NULL) { 1090 error_setg(errp, "No memory"); 1091 return NULL; 1092 } 1093 1094 dbi = bdrv_dirty_iter_new(bitmap, 0); 1095 buf = g_malloc(s->cluster_size); 1096 sbc = sectors_covered_by_bitmap_cluster(s, bitmap); 1097 assert(DIV_ROUND_UP(bm_size, sbc) == tb_size); 1098 1099 while ((sector = bdrv_dirty_iter_next(dbi)) != -1) { 1100 uint64_t cluster = sector / sbc; 1101 uint64_t end, write_size; 1102 int64_t off; 1103 1104 sector = cluster * sbc; 1105 end = MIN(bm_size, sector + sbc); 1106 write_size = 1107 bdrv_dirty_bitmap_serialization_size(bitmap, sector, end - sector); 1108 assert(write_size <= s->cluster_size); 1109 1110 off = qcow2_alloc_clusters(bs, s->cluster_size); 1111 if (off < 0) { 1112 error_setg_errno(errp, -off, 1113 "Failed to allocate clusters for bitmap '%s'", 1114 bm_name); 1115 goto fail; 1116 } 1117 tb[cluster] = off; 1118 1119 bdrv_dirty_bitmap_serialize_part(bitmap, buf, sector, end - sector); 1120 if (write_size < s->cluster_size) { 1121 memset(buf + write_size, 0, s->cluster_size - write_size); 1122 } 1123 1124 ret = qcow2_pre_write_overlap_check(bs, 0, off, s->cluster_size); 1125 if (ret < 0) { 1126 error_setg_errno(errp, -ret, "Qcow2 overlap check failed"); 1127 goto fail; 1128 } 1129 1130 ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size); 1131 if (ret < 0) { 1132 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file", 1133 bm_name); 1134 goto fail; 1135 } 1136 1137 if (end >= bm_size) { 1138 break; 1139 } 1140 1141 bdrv_set_dirty_iter(dbi, end); 1142 } 1143 1144 *bitmap_table_size = tb_size; 1145 g_free(buf); 1146 bdrv_dirty_iter_free(dbi); 1147 1148 return tb; 1149 1150 fail: 1151 clear_bitmap_table(bs, tb, tb_size); 1152 g_free(buf); 1153 bdrv_dirty_iter_free(dbi); 1154 g_free(tb); 1155 1156 return NULL; 1157 } 1158 1159 /* store_bitmap() 1160 * Store bm->dirty_bitmap to qcow2. 1161 * Set bm->table_offset and bm->table_size accordingly. 1162 */ 1163 static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp) 1164 { 1165 int ret; 1166 uint64_t *tb; 1167 int64_t tb_offset; 1168 uint32_t tb_size; 1169 BdrvDirtyBitmap *bitmap = bm->dirty_bitmap; 1170 const char *bm_name; 1171 1172 assert(bitmap != NULL); 1173 1174 bm_name = bdrv_dirty_bitmap_name(bitmap); 1175 1176 tb = store_bitmap_data(bs, bitmap, &tb_size, errp); 1177 if (tb == NULL) { 1178 return -EINVAL; 1179 } 1180 1181 assert(tb_size <= BME_MAX_TABLE_SIZE); 1182 tb_offset = qcow2_alloc_clusters(bs, tb_size * sizeof(tb[0])); 1183 if (tb_offset < 0) { 1184 error_setg_errno(errp, -tb_offset, 1185 "Failed to allocate clusters for bitmap '%s'", 1186 bm_name); 1187 ret = tb_offset; 1188 goto fail; 1189 } 1190 1191 ret = qcow2_pre_write_overlap_check(bs, 0, tb_offset, 1192 tb_size * sizeof(tb[0])); 1193 if (ret < 0) { 1194 error_setg_errno(errp, -ret, "Qcow2 overlap check failed"); 1195 goto fail; 1196 } 1197 1198 bitmap_table_to_be(tb, tb_size); 1199 ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0])); 1200 if (ret < 0) { 1201 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file", 1202 bm_name); 1203 goto fail; 1204 } 1205 1206 g_free(tb); 1207 1208 bm->table.offset = tb_offset; 1209 bm->table.size = tb_size; 1210 1211 return 0; 1212 1213 fail: 1214 clear_bitmap_table(bs, tb, tb_size); 1215 1216 if (tb_offset > 0) { 1217 qcow2_free_clusters(bs, tb_offset, tb_size * sizeof(tb[0]), 1218 QCOW2_DISCARD_OTHER); 1219 } 1220 1221 g_free(tb); 1222 1223 return ret; 1224 } 1225 1226 static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list, 1227 const char *name) 1228 { 1229 Qcow2Bitmap *bm; 1230 1231 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1232 if (strcmp(name, bm->name) == 0) { 1233 return bm; 1234 } 1235 } 1236 1237 return NULL; 1238 } 1239 1240 void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, 1241 const char *name, 1242 Error **errp) 1243 { 1244 int ret; 1245 BDRVQcow2State *s = bs->opaque; 1246 Qcow2Bitmap *bm; 1247 Qcow2BitmapList *bm_list; 1248 1249 if (s->nb_bitmaps == 0) { 1250 /* Absence of the bitmap is not an error: see explanation above 1251 * bdrv_remove_persistent_dirty_bitmap() definition. */ 1252 return; 1253 } 1254 1255 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1256 s->bitmap_directory_size, errp); 1257 if (bm_list == NULL) { 1258 return; 1259 } 1260 1261 bm = find_bitmap_by_name(bm_list, name); 1262 if (bm == NULL) { 1263 goto fail; 1264 } 1265 1266 QSIMPLEQ_REMOVE(bm_list, bm, Qcow2Bitmap, entry); 1267 1268 ret = update_ext_header_and_dir(bs, bm_list); 1269 if (ret < 0) { 1270 error_setg_errno(errp, -ret, "Failed to update bitmap extension"); 1271 goto fail; 1272 } 1273 1274 free_bitmap_clusters(bs, &bm->table); 1275 1276 fail: 1277 bitmap_free(bm); 1278 bitmap_list_free(bm_list); 1279 } 1280 1281 void qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, Error **errp) 1282 { 1283 BdrvDirtyBitmap *bitmap; 1284 BDRVQcow2State *s = bs->opaque; 1285 uint32_t new_nb_bitmaps = s->nb_bitmaps; 1286 uint64_t new_dir_size = s->bitmap_directory_size; 1287 int ret; 1288 Qcow2BitmapList *bm_list; 1289 Qcow2Bitmap *bm; 1290 Qcow2BitmapTableList drop_tables; 1291 Qcow2BitmapTable *tb, *tb_next; 1292 1293 if (!bdrv_has_changed_persistent_bitmaps(bs)) { 1294 /* nothing to do */ 1295 return; 1296 } 1297 1298 if (!can_write(bs)) { 1299 error_setg(errp, "No write access"); 1300 return; 1301 } 1302 1303 QSIMPLEQ_INIT(&drop_tables); 1304 1305 if (s->nb_bitmaps == 0) { 1306 bm_list = bitmap_list_new(); 1307 } else { 1308 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1309 s->bitmap_directory_size, errp); 1310 if (bm_list == NULL) { 1311 return; 1312 } 1313 } 1314 1315 /* check constraints and names */ 1316 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL; 1317 bitmap = bdrv_dirty_bitmap_next(bs, bitmap)) 1318 { 1319 const char *name = bdrv_dirty_bitmap_name(bitmap); 1320 uint32_t granularity = bdrv_dirty_bitmap_granularity(bitmap); 1321 Qcow2Bitmap *bm; 1322 1323 if (!bdrv_dirty_bitmap_get_persistance(bitmap) || 1324 bdrv_dirty_bitmap_readonly(bitmap)) 1325 { 1326 continue; 1327 } 1328 1329 if (check_constraints_on_bitmap(bs, name, granularity, errp) < 0) { 1330 error_prepend(errp, "Bitmap '%s' doesn't satisfy the constraints: ", 1331 name); 1332 goto fail; 1333 } 1334 1335 bm = find_bitmap_by_name(bm_list, name); 1336 if (bm == NULL) { 1337 if (++new_nb_bitmaps > QCOW2_MAX_BITMAPS) { 1338 error_setg(errp, "Too many persistent bitmaps"); 1339 goto fail; 1340 } 1341 1342 new_dir_size += calc_dir_entry_size(strlen(name), 0); 1343 if (new_dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 1344 error_setg(errp, "Bitmap directory is too large"); 1345 goto fail; 1346 } 1347 1348 bm = g_new0(Qcow2Bitmap, 1); 1349 bm->name = g_strdup(name); 1350 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry); 1351 } else { 1352 if (!(bm->flags & BME_FLAG_IN_USE)) { 1353 error_setg(errp, "Bitmap '%s' already exists in the image", 1354 name); 1355 goto fail; 1356 } 1357 tb = g_memdup(&bm->table, sizeof(bm->table)); 1358 bm->table.offset = 0; 1359 bm->table.size = 0; 1360 QSIMPLEQ_INSERT_TAIL(&drop_tables, tb, entry); 1361 } 1362 bm->flags = bdrv_dirty_bitmap_get_autoload(bitmap) ? BME_FLAG_AUTO : 0; 1363 bm->granularity_bits = ctz32(bdrv_dirty_bitmap_granularity(bitmap)); 1364 bm->dirty_bitmap = bitmap; 1365 } 1366 1367 /* allocate clusters and store bitmaps */ 1368 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1369 if (bm->dirty_bitmap == NULL) { 1370 continue; 1371 } 1372 1373 ret = store_bitmap(bs, bm, errp); 1374 if (ret < 0) { 1375 goto fail; 1376 } 1377 } 1378 1379 ret = update_ext_header_and_dir(bs, bm_list); 1380 if (ret < 0) { 1381 error_setg_errno(errp, -ret, "Failed to update bitmap extension"); 1382 goto fail; 1383 } 1384 1385 /* Bitmap directory was successfully updated, so, old data can be dropped. 1386 * TODO it is better to reuse these clusters */ 1387 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) { 1388 free_bitmap_clusters(bs, tb); 1389 g_free(tb); 1390 } 1391 1392 bitmap_list_free(bm_list); 1393 return; 1394 1395 fail: 1396 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1397 if (bm->dirty_bitmap == NULL || bm->table.offset == 0) { 1398 continue; 1399 } 1400 1401 free_bitmap_clusters(bs, &bm->table); 1402 } 1403 1404 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) { 1405 g_free(tb); 1406 } 1407 1408 bitmap_list_free(bm_list); 1409 } 1410 1411 int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp) 1412 { 1413 BdrvDirtyBitmap *bitmap; 1414 Error *local_err = NULL; 1415 1416 qcow2_store_persistent_dirty_bitmaps(bs, &local_err); 1417 if (local_err != NULL) { 1418 error_propagate(errp, local_err); 1419 return -EINVAL; 1420 } 1421 1422 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL; 1423 bitmap = bdrv_dirty_bitmap_next(bs, bitmap)) 1424 { 1425 if (bdrv_dirty_bitmap_get_persistance(bitmap)) { 1426 bdrv_dirty_bitmap_set_readonly(bitmap, true); 1427 } 1428 } 1429 1430 return 0; 1431 } 1432 1433 bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs, 1434 const char *name, 1435 uint32_t granularity, 1436 Error **errp) 1437 { 1438 BDRVQcow2State *s = bs->opaque; 1439 bool found; 1440 Qcow2BitmapList *bm_list; 1441 1442 if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) { 1443 goto fail; 1444 } 1445 1446 if (s->nb_bitmaps == 0) { 1447 return true; 1448 } 1449 1450 if (s->nb_bitmaps >= QCOW2_MAX_BITMAPS) { 1451 error_setg(errp, 1452 "Maximum number of persistent bitmaps is already reached"); 1453 goto fail; 1454 } 1455 1456 if (s->bitmap_directory_size + calc_dir_entry_size(strlen(name), 0) > 1457 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) 1458 { 1459 error_setg(errp, "Not enough space in the bitmap directory"); 1460 goto fail; 1461 } 1462 1463 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1464 s->bitmap_directory_size, errp); 1465 if (bm_list == NULL) { 1466 goto fail; 1467 } 1468 1469 found = find_bitmap_by_name(bm_list, name); 1470 bitmap_list_free(bm_list); 1471 if (found) { 1472 error_setg(errp, "Bitmap with the same name is already stored"); 1473 goto fail; 1474 } 1475 1476 return true; 1477 1478 fail: 1479 error_prepend(errp, "Can't make bitmap '%s' persistent in '%s': ", 1480 name, bdrv_get_device_or_node_name(bs)); 1481 return false; 1482 } 1483