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 "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->file->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 return ret; 258 } 259 260 clear_bitmap_table(bs, bitmap_table, tb->size); 261 qcow2_free_clusters(bs, tb->offset, tb->size * sizeof(uint64_t), 262 QCOW2_DISCARD_OTHER); 263 g_free(bitmap_table); 264 265 tb->offset = 0; 266 tb->size = 0; 267 268 return 0; 269 } 270 271 /* Return the disk size covered by a single qcow2 cluster of bitmap data. */ 272 static uint64_t bytes_covered_by_bitmap_cluster(const BDRVQcow2State *s, 273 const BdrvDirtyBitmap *bitmap) 274 { 275 uint64_t granularity = bdrv_dirty_bitmap_granularity(bitmap); 276 uint64_t limit = granularity * (s->cluster_size << 3); 277 278 assert(QEMU_IS_ALIGNED(limit, 279 bdrv_dirty_bitmap_serialization_align(bitmap))); 280 return limit; 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 offset, limit; 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 limit = bytes_covered_by_bitmap_cluster(s, bitmap); 306 for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) { 307 uint64_t count = MIN(bm_size - offset, limit); 308 uint64_t entry = bitmap_table[i]; 309 uint64_t data_offset = entry & BME_TABLE_ENTRY_OFFSET_MASK; 310 311 assert(check_table_entry(entry, s->cluster_size) == 0); 312 313 if (data_offset == 0) { 314 if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) { 315 bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, 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, data_offset, buf, s->cluster_size); 323 if (ret < 0) { 324 goto finish; 325 } 326 bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, 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 int size = sizeof(Qcow2BitmapDirEntry) + name_size + extra_data_size; 416 return ROUND_UP(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 if (bm == NULL) { 491 return; 492 } 493 494 g_free(bm->name); 495 g_free(bm); 496 } 497 498 static void bitmap_list_free(Qcow2BitmapList *bm_list) 499 { 500 Qcow2Bitmap *bm; 501 502 if (bm_list == NULL) { 503 return; 504 } 505 506 while ((bm = QSIMPLEQ_FIRST(bm_list)) != NULL) { 507 QSIMPLEQ_REMOVE_HEAD(bm_list, entry); 508 bitmap_free(bm); 509 } 510 511 g_free(bm_list); 512 } 513 514 static Qcow2BitmapList *bitmap_list_new(void) 515 { 516 Qcow2BitmapList *bm_list = g_new(Qcow2BitmapList, 1); 517 QSIMPLEQ_INIT(bm_list); 518 519 return bm_list; 520 } 521 522 static uint32_t bitmap_list_count(Qcow2BitmapList *bm_list) 523 { 524 Qcow2Bitmap *bm; 525 uint32_t nb_bitmaps = 0; 526 527 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 528 nb_bitmaps++; 529 } 530 531 return nb_bitmaps; 532 } 533 534 /* bitmap_list_load 535 * Get bitmap list from qcow2 image. Actually reads bitmap directory, 536 * checks it and convert to bitmap list. 537 */ 538 static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset, 539 uint64_t size, Error **errp) 540 { 541 int ret; 542 BDRVQcow2State *s = bs->opaque; 543 uint8_t *dir, *dir_end; 544 Qcow2BitmapDirEntry *e; 545 uint32_t nb_dir_entries = 0; 546 Qcow2BitmapList *bm_list = NULL; 547 548 if (size == 0) { 549 error_setg(errp, "Requested bitmap directory size is zero"); 550 return NULL; 551 } 552 553 if (size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 554 error_setg(errp, "Requested bitmap directory size is too big"); 555 return NULL; 556 } 557 558 dir = g_try_malloc(size); 559 if (dir == NULL) { 560 error_setg(errp, "Failed to allocate space for bitmap directory"); 561 return NULL; 562 } 563 dir_end = dir + size; 564 565 ret = bdrv_pread(bs->file, offset, dir, size); 566 if (ret < 0) { 567 error_setg_errno(errp, -ret, "Failed to read bitmap directory"); 568 goto fail; 569 } 570 571 bm_list = bitmap_list_new(); 572 for (e = (Qcow2BitmapDirEntry *)dir; 573 e < (Qcow2BitmapDirEntry *)dir_end; 574 e = next_dir_entry(e)) 575 { 576 Qcow2Bitmap *bm; 577 578 if ((uint8_t *)(e + 1) > dir_end) { 579 goto broken_dir; 580 } 581 582 if (++nb_dir_entries > s->nb_bitmaps) { 583 error_setg(errp, "More bitmaps found than specified in header" 584 " extension"); 585 goto fail; 586 } 587 bitmap_dir_entry_to_cpu(e); 588 589 if ((uint8_t *)next_dir_entry(e) > dir_end) { 590 goto broken_dir; 591 } 592 593 if (e->extra_data_size != 0) { 594 error_setg(errp, "Bitmap extra data is not supported"); 595 goto fail; 596 } 597 598 ret = check_dir_entry(bs, e); 599 if (ret < 0) { 600 error_setg(errp, "Bitmap '%.*s' doesn't satisfy the constraints", 601 e->name_size, dir_entry_name_field(e)); 602 goto fail; 603 } 604 605 bm = g_new0(Qcow2Bitmap, 1); 606 bm->table.offset = e->bitmap_table_offset; 607 bm->table.size = e->bitmap_table_size; 608 bm->flags = e->flags; 609 bm->granularity_bits = e->granularity_bits; 610 bm->name = dir_entry_copy_name(e); 611 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry); 612 } 613 614 if (nb_dir_entries != s->nb_bitmaps) { 615 error_setg(errp, "Less bitmaps found than specified in header" 616 " extension"); 617 goto fail; 618 } 619 620 if ((uint8_t *)e != dir_end) { 621 goto broken_dir; 622 } 623 624 g_free(dir); 625 return bm_list; 626 627 broken_dir: 628 ret = -EINVAL; 629 error_setg(errp, "Broken bitmap directory"); 630 631 fail: 632 g_free(dir); 633 bitmap_list_free(bm_list); 634 635 return NULL; 636 } 637 638 int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res, 639 void **refcount_table, 640 int64_t *refcount_table_size) 641 { 642 int ret; 643 BDRVQcow2State *s = bs->opaque; 644 Qcow2BitmapList *bm_list; 645 Qcow2Bitmap *bm; 646 647 if (s->nb_bitmaps == 0) { 648 return 0; 649 } 650 651 ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size, 652 s->bitmap_directory_offset, 653 s->bitmap_directory_size); 654 if (ret < 0) { 655 return ret; 656 } 657 658 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 659 s->bitmap_directory_size, NULL); 660 if (bm_list == NULL) { 661 res->corruptions++; 662 return -EINVAL; 663 } 664 665 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 666 uint64_t *bitmap_table = NULL; 667 int i; 668 669 ret = qcow2_inc_refcounts_imrt(bs, res, 670 refcount_table, refcount_table_size, 671 bm->table.offset, 672 bm->table.size * sizeof(uint64_t)); 673 if (ret < 0) { 674 goto out; 675 } 676 677 ret = bitmap_table_load(bs, &bm->table, &bitmap_table); 678 if (ret < 0) { 679 res->corruptions++; 680 goto out; 681 } 682 683 for (i = 0; i < bm->table.size; ++i) { 684 uint64_t entry = bitmap_table[i]; 685 uint64_t offset = entry & BME_TABLE_ENTRY_OFFSET_MASK; 686 687 if (check_table_entry(entry, s->cluster_size) < 0) { 688 res->corruptions++; 689 continue; 690 } 691 692 if (offset == 0) { 693 continue; 694 } 695 696 ret = qcow2_inc_refcounts_imrt(bs, res, 697 refcount_table, refcount_table_size, 698 offset, s->cluster_size); 699 if (ret < 0) { 700 g_free(bitmap_table); 701 goto out; 702 } 703 } 704 705 g_free(bitmap_table); 706 } 707 708 out: 709 bitmap_list_free(bm_list); 710 711 return ret; 712 } 713 714 /* bitmap_list_store 715 * Store bitmap list to qcow2 image as a bitmap directory. 716 * Everything is checked. 717 */ 718 static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list, 719 uint64_t *offset, uint64_t *size, bool in_place) 720 { 721 int ret; 722 uint8_t *dir; 723 int64_t dir_offset = 0; 724 uint64_t dir_size = 0; 725 Qcow2Bitmap *bm; 726 Qcow2BitmapDirEntry *e; 727 728 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 729 dir_size += calc_dir_entry_size(strlen(bm->name), 0); 730 } 731 732 if (dir_size == 0 || dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 733 return -EINVAL; 734 } 735 736 if (in_place) { 737 if (*size != dir_size || *offset == 0) { 738 return -EINVAL; 739 } 740 741 dir_offset = *offset; 742 } 743 744 dir = g_try_malloc(dir_size); 745 if (dir == NULL) { 746 return -ENOMEM; 747 } 748 749 e = (Qcow2BitmapDirEntry *)dir; 750 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 751 e->bitmap_table_offset = bm->table.offset; 752 e->bitmap_table_size = bm->table.size; 753 e->flags = bm->flags; 754 e->type = BT_DIRTY_TRACKING_BITMAP; 755 e->granularity_bits = bm->granularity_bits; 756 e->name_size = strlen(bm->name); 757 e->extra_data_size = 0; 758 memcpy(e + 1, bm->name, e->name_size); 759 760 if (check_dir_entry(bs, e) < 0) { 761 ret = -EINVAL; 762 goto fail; 763 } 764 765 e = next_dir_entry(e); 766 } 767 768 bitmap_directory_to_be(dir, dir_size); 769 770 if (!in_place) { 771 dir_offset = qcow2_alloc_clusters(bs, dir_size); 772 if (dir_offset < 0) { 773 ret = dir_offset; 774 goto fail; 775 } 776 } 777 778 ret = qcow2_pre_write_overlap_check(bs, 0, dir_offset, dir_size); 779 if (ret < 0) { 780 goto fail; 781 } 782 783 ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size); 784 if (ret < 0) { 785 goto fail; 786 } 787 788 g_free(dir); 789 790 if (!in_place) { 791 *size = dir_size; 792 *offset = dir_offset; 793 } 794 795 return 0; 796 797 fail: 798 g_free(dir); 799 800 if (!in_place && dir_offset > 0) { 801 qcow2_free_clusters(bs, dir_offset, dir_size, QCOW2_DISCARD_OTHER); 802 } 803 804 return ret; 805 } 806 807 /* 808 * Bitmap List end 809 */ 810 811 static int update_ext_header_and_dir_in_place(BlockDriverState *bs, 812 Qcow2BitmapList *bm_list) 813 { 814 BDRVQcow2State *s = bs->opaque; 815 int ret; 816 817 if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS) || 818 bm_list == NULL || QSIMPLEQ_EMPTY(bm_list) || 819 bitmap_list_count(bm_list) != s->nb_bitmaps) 820 { 821 return -EINVAL; 822 } 823 824 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS; 825 ret = update_header_sync(bs); 826 if (ret < 0) { 827 /* Two variants are possible here: 828 * 1. Autoclear flag is dropped, all bitmaps will be lost. 829 * 2. Autoclear flag is not dropped, old state is left. 830 */ 831 return ret; 832 } 833 834 /* autoclear bit is not set, so we can safely update bitmap directory */ 835 836 ret = bitmap_list_store(bs, bm_list, &s->bitmap_directory_offset, 837 &s->bitmap_directory_size, true); 838 if (ret < 0) { 839 /* autoclear bit is cleared, so all leaked clusters would be removed on 840 * qemu-img check */ 841 return ret; 842 } 843 844 ret = update_header_sync(bs); 845 if (ret < 0) { 846 /* autoclear bit is cleared, so all leaked clusters would be removed on 847 * qemu-img check */ 848 return ret; 849 } 850 851 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS; 852 return update_header_sync(bs); 853 /* If final update_header_sync() fails, two variants are possible: 854 * 1. Autoclear flag is not set, all bitmaps will be lost. 855 * 2. Autoclear flag is set, header and directory are successfully updated. 856 */ 857 } 858 859 static int update_ext_header_and_dir(BlockDriverState *bs, 860 Qcow2BitmapList *bm_list) 861 { 862 BDRVQcow2State *s = bs->opaque; 863 int ret; 864 uint64_t new_offset = 0; 865 uint64_t new_size = 0; 866 uint32_t new_nb_bitmaps = 0; 867 uint64_t old_offset = s->bitmap_directory_offset; 868 uint64_t old_size = s->bitmap_directory_size; 869 uint32_t old_nb_bitmaps = s->nb_bitmaps; 870 uint64_t old_autocl = s->autoclear_features; 871 872 if (bm_list != NULL && !QSIMPLEQ_EMPTY(bm_list)) { 873 new_nb_bitmaps = bitmap_list_count(bm_list); 874 875 if (new_nb_bitmaps > QCOW2_MAX_BITMAPS) { 876 return -EINVAL; 877 } 878 879 ret = bitmap_list_store(bs, bm_list, &new_offset, &new_size, false); 880 if (ret < 0) { 881 return ret; 882 } 883 884 ret = qcow2_flush_caches(bs); 885 if (ret < 0) { 886 goto fail; 887 } 888 889 s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS; 890 } else { 891 s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS; 892 } 893 894 s->bitmap_directory_offset = new_offset; 895 s->bitmap_directory_size = new_size; 896 s->nb_bitmaps = new_nb_bitmaps; 897 898 ret = update_header_sync(bs); 899 if (ret < 0) { 900 goto fail; 901 } 902 903 if (old_size > 0) { 904 qcow2_free_clusters(bs, old_offset, old_size, QCOW2_DISCARD_OTHER); 905 } 906 907 return 0; 908 909 fail: 910 if (new_offset > 0) { 911 qcow2_free_clusters(bs, new_offset, new_size, QCOW2_DISCARD_OTHER); 912 } 913 914 s->bitmap_directory_offset = old_offset; 915 s->bitmap_directory_size = old_size; 916 s->nb_bitmaps = old_nb_bitmaps; 917 s->autoclear_features = old_autocl; 918 919 return ret; 920 } 921 922 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */ 923 static void release_dirty_bitmap_helper(gpointer bitmap, 924 gpointer bs) 925 { 926 bdrv_release_dirty_bitmap(bs, bitmap); 927 } 928 929 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */ 930 static void set_readonly_helper(gpointer bitmap, gpointer value) 931 { 932 bdrv_dirty_bitmap_set_readonly(bitmap, (bool)value); 933 } 934 935 /* qcow2_load_dirty_bitmaps() 936 * Return value is a hint for caller: true means that the Qcow2 header was 937 * updated. (false doesn't mean that the header should be updated by the 938 * caller, it just means that updating was not needed or the image cannot be 939 * written to). 940 * On failure the function returns false. 941 */ 942 bool qcow2_load_dirty_bitmaps(BlockDriverState *bs, Error **errp) 943 { 944 BDRVQcow2State *s = bs->opaque; 945 Qcow2BitmapList *bm_list; 946 Qcow2Bitmap *bm; 947 GSList *created_dirty_bitmaps = NULL; 948 bool header_updated = false; 949 950 if (s->nb_bitmaps == 0) { 951 /* No bitmaps - nothing to do */ 952 return false; 953 } 954 955 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 956 s->bitmap_directory_size, errp); 957 if (bm_list == NULL) { 958 return false; 959 } 960 961 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 962 if (!(bm->flags & BME_FLAG_IN_USE)) { 963 BdrvDirtyBitmap *bitmap = load_bitmap(bs, bm, errp); 964 if (bitmap == NULL) { 965 goto fail; 966 } 967 968 if (!(bm->flags & BME_FLAG_AUTO)) { 969 bdrv_disable_dirty_bitmap(bitmap); 970 } 971 bdrv_dirty_bitmap_set_persistance(bitmap, true); 972 bm->flags |= BME_FLAG_IN_USE; 973 created_dirty_bitmaps = 974 g_slist_append(created_dirty_bitmaps, bitmap); 975 } 976 } 977 978 if (created_dirty_bitmaps != NULL) { 979 if (can_write(bs)) { 980 /* in_use flags must be updated */ 981 int ret = update_ext_header_and_dir_in_place(bs, bm_list); 982 if (ret < 0) { 983 error_setg_errno(errp, -ret, "Can't update bitmap directory"); 984 goto fail; 985 } 986 header_updated = true; 987 } else { 988 g_slist_foreach(created_dirty_bitmaps, set_readonly_helper, 989 (gpointer)true); 990 } 991 } 992 993 g_slist_free(created_dirty_bitmaps); 994 bitmap_list_free(bm_list); 995 996 return header_updated; 997 998 fail: 999 g_slist_foreach(created_dirty_bitmaps, release_dirty_bitmap_helper, bs); 1000 g_slist_free(created_dirty_bitmaps); 1001 bitmap_list_free(bm_list); 1002 1003 return false; 1004 } 1005 1006 int qcow2_reopen_bitmaps_rw_hint(BlockDriverState *bs, bool *header_updated, 1007 Error **errp) 1008 { 1009 BDRVQcow2State *s = bs->opaque; 1010 Qcow2BitmapList *bm_list; 1011 Qcow2Bitmap *bm; 1012 GSList *ro_dirty_bitmaps = NULL; 1013 int ret = 0; 1014 1015 if (header_updated != NULL) { 1016 *header_updated = false; 1017 } 1018 1019 if (s->nb_bitmaps == 0) { 1020 /* No bitmaps - nothing to do */ 1021 return 0; 1022 } 1023 1024 if (!can_write(bs)) { 1025 error_setg(errp, "Can't write to the image on reopening bitmaps rw"); 1026 return -EINVAL; 1027 } 1028 1029 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1030 s->bitmap_directory_size, errp); 1031 if (bm_list == NULL) { 1032 return -EINVAL; 1033 } 1034 1035 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1036 if (!(bm->flags & BME_FLAG_IN_USE)) { 1037 BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name); 1038 if (bitmap == NULL) { 1039 continue; 1040 } 1041 1042 if (!bdrv_dirty_bitmap_readonly(bitmap)) { 1043 error_setg(errp, "Bitmap %s is not readonly but not marked" 1044 "'IN_USE' in the image. Something went wrong," 1045 "all the bitmaps may be corrupted", bm->name); 1046 ret = -EINVAL; 1047 goto out; 1048 } 1049 1050 bm->flags |= BME_FLAG_IN_USE; 1051 ro_dirty_bitmaps = g_slist_append(ro_dirty_bitmaps, bitmap); 1052 } 1053 } 1054 1055 if (ro_dirty_bitmaps != NULL) { 1056 /* in_use flags must be updated */ 1057 ret = update_ext_header_and_dir_in_place(bs, bm_list); 1058 if (ret < 0) { 1059 error_setg_errno(errp, -ret, "Can't update bitmap directory"); 1060 goto out; 1061 } 1062 if (header_updated != NULL) { 1063 *header_updated = true; 1064 } 1065 g_slist_foreach(ro_dirty_bitmaps, set_readonly_helper, false); 1066 } 1067 1068 out: 1069 g_slist_free(ro_dirty_bitmaps); 1070 bitmap_list_free(bm_list); 1071 1072 return ret; 1073 } 1074 1075 int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp) 1076 { 1077 return qcow2_reopen_bitmaps_rw_hint(bs, NULL, errp); 1078 } 1079 1080 /* store_bitmap_data() 1081 * Store bitmap to image, filling bitmap table accordingly. 1082 */ 1083 static uint64_t *store_bitmap_data(BlockDriverState *bs, 1084 BdrvDirtyBitmap *bitmap, 1085 uint32_t *bitmap_table_size, Error **errp) 1086 { 1087 int ret; 1088 BDRVQcow2State *s = bs->opaque; 1089 int64_t offset; 1090 uint64_t limit; 1091 uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap); 1092 const char *bm_name = bdrv_dirty_bitmap_name(bitmap); 1093 uint8_t *buf = NULL; 1094 BdrvDirtyBitmapIter *dbi; 1095 uint64_t *tb; 1096 uint64_t tb_size = 1097 size_to_clusters(s, 1098 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size)); 1099 1100 if (tb_size > BME_MAX_TABLE_SIZE || 1101 tb_size * s->cluster_size > BME_MAX_PHYS_SIZE) 1102 { 1103 error_setg(errp, "Bitmap '%s' is too big", bm_name); 1104 return NULL; 1105 } 1106 1107 tb = g_try_new0(uint64_t, tb_size); 1108 if (tb == NULL) { 1109 error_setg(errp, "No memory"); 1110 return NULL; 1111 } 1112 1113 dbi = bdrv_dirty_iter_new(bitmap); 1114 buf = g_malloc(s->cluster_size); 1115 limit = bytes_covered_by_bitmap_cluster(s, bitmap); 1116 assert(DIV_ROUND_UP(bm_size, limit) == tb_size); 1117 1118 while ((offset = bdrv_dirty_iter_next(dbi)) >= 0) { 1119 uint64_t cluster = offset / limit; 1120 uint64_t end, write_size; 1121 int64_t off; 1122 1123 /* 1124 * We found the first dirty offset, but want to write out the 1125 * entire cluster of the bitmap that includes that offset, 1126 * including any leading zero bits. 1127 */ 1128 offset = QEMU_ALIGN_DOWN(offset, limit); 1129 end = MIN(bm_size, offset + limit); 1130 write_size = bdrv_dirty_bitmap_serialization_size(bitmap, offset, 1131 end - offset); 1132 assert(write_size <= s->cluster_size); 1133 1134 off = qcow2_alloc_clusters(bs, s->cluster_size); 1135 if (off < 0) { 1136 error_setg_errno(errp, -off, 1137 "Failed to allocate clusters for bitmap '%s'", 1138 bm_name); 1139 goto fail; 1140 } 1141 tb[cluster] = off; 1142 1143 bdrv_dirty_bitmap_serialize_part(bitmap, buf, offset, end - offset); 1144 if (write_size < s->cluster_size) { 1145 memset(buf + write_size, 0, s->cluster_size - write_size); 1146 } 1147 1148 ret = qcow2_pre_write_overlap_check(bs, 0, off, s->cluster_size); 1149 if (ret < 0) { 1150 error_setg_errno(errp, -ret, "Qcow2 overlap check failed"); 1151 goto fail; 1152 } 1153 1154 ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size); 1155 if (ret < 0) { 1156 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file", 1157 bm_name); 1158 goto fail; 1159 } 1160 1161 if (end >= bm_size) { 1162 break; 1163 } 1164 1165 bdrv_set_dirty_iter(dbi, end); 1166 } 1167 1168 *bitmap_table_size = tb_size; 1169 g_free(buf); 1170 bdrv_dirty_iter_free(dbi); 1171 1172 return tb; 1173 1174 fail: 1175 clear_bitmap_table(bs, tb, tb_size); 1176 g_free(buf); 1177 bdrv_dirty_iter_free(dbi); 1178 g_free(tb); 1179 1180 return NULL; 1181 } 1182 1183 /* store_bitmap() 1184 * Store bm->dirty_bitmap to qcow2. 1185 * Set bm->table_offset and bm->table_size accordingly. 1186 */ 1187 static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp) 1188 { 1189 int ret; 1190 uint64_t *tb; 1191 int64_t tb_offset; 1192 uint32_t tb_size; 1193 BdrvDirtyBitmap *bitmap = bm->dirty_bitmap; 1194 const char *bm_name; 1195 1196 assert(bitmap != NULL); 1197 1198 bm_name = bdrv_dirty_bitmap_name(bitmap); 1199 1200 tb = store_bitmap_data(bs, bitmap, &tb_size, errp); 1201 if (tb == NULL) { 1202 return -EINVAL; 1203 } 1204 1205 assert(tb_size <= BME_MAX_TABLE_SIZE); 1206 tb_offset = qcow2_alloc_clusters(bs, tb_size * sizeof(tb[0])); 1207 if (tb_offset < 0) { 1208 error_setg_errno(errp, -tb_offset, 1209 "Failed to allocate clusters for bitmap '%s'", 1210 bm_name); 1211 ret = tb_offset; 1212 goto fail; 1213 } 1214 1215 ret = qcow2_pre_write_overlap_check(bs, 0, tb_offset, 1216 tb_size * sizeof(tb[0])); 1217 if (ret < 0) { 1218 error_setg_errno(errp, -ret, "Qcow2 overlap check failed"); 1219 goto fail; 1220 } 1221 1222 bitmap_table_to_be(tb, tb_size); 1223 ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0])); 1224 if (ret < 0) { 1225 error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file", 1226 bm_name); 1227 goto fail; 1228 } 1229 1230 g_free(tb); 1231 1232 bm->table.offset = tb_offset; 1233 bm->table.size = tb_size; 1234 1235 return 0; 1236 1237 fail: 1238 clear_bitmap_table(bs, tb, tb_size); 1239 1240 if (tb_offset > 0) { 1241 qcow2_free_clusters(bs, tb_offset, tb_size * sizeof(tb[0]), 1242 QCOW2_DISCARD_OTHER); 1243 } 1244 1245 g_free(tb); 1246 1247 return ret; 1248 } 1249 1250 static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list, 1251 const char *name) 1252 { 1253 Qcow2Bitmap *bm; 1254 1255 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1256 if (strcmp(name, bm->name) == 0) { 1257 return bm; 1258 } 1259 } 1260 1261 return NULL; 1262 } 1263 1264 void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs, 1265 const char *name, 1266 Error **errp) 1267 { 1268 int ret; 1269 BDRVQcow2State *s = bs->opaque; 1270 Qcow2Bitmap *bm; 1271 Qcow2BitmapList *bm_list; 1272 1273 if (s->nb_bitmaps == 0) { 1274 /* Absence of the bitmap is not an error: see explanation above 1275 * bdrv_remove_persistent_dirty_bitmap() definition. */ 1276 return; 1277 } 1278 1279 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1280 s->bitmap_directory_size, errp); 1281 if (bm_list == NULL) { 1282 return; 1283 } 1284 1285 bm = find_bitmap_by_name(bm_list, name); 1286 if (bm == NULL) { 1287 goto fail; 1288 } 1289 1290 QSIMPLEQ_REMOVE(bm_list, bm, Qcow2Bitmap, entry); 1291 1292 ret = update_ext_header_and_dir(bs, bm_list); 1293 if (ret < 0) { 1294 error_setg_errno(errp, -ret, "Failed to update bitmap extension"); 1295 goto fail; 1296 } 1297 1298 free_bitmap_clusters(bs, &bm->table); 1299 1300 fail: 1301 bitmap_free(bm); 1302 bitmap_list_free(bm_list); 1303 } 1304 1305 void qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, Error **errp) 1306 { 1307 BdrvDirtyBitmap *bitmap; 1308 BDRVQcow2State *s = bs->opaque; 1309 uint32_t new_nb_bitmaps = s->nb_bitmaps; 1310 uint64_t new_dir_size = s->bitmap_directory_size; 1311 int ret; 1312 Qcow2BitmapList *bm_list; 1313 Qcow2Bitmap *bm; 1314 Qcow2BitmapTableList drop_tables; 1315 Qcow2BitmapTable *tb, *tb_next; 1316 1317 if (!bdrv_has_changed_persistent_bitmaps(bs)) { 1318 /* nothing to do */ 1319 return; 1320 } 1321 1322 if (!can_write(bs)) { 1323 error_setg(errp, "No write access"); 1324 return; 1325 } 1326 1327 QSIMPLEQ_INIT(&drop_tables); 1328 1329 if (s->nb_bitmaps == 0) { 1330 bm_list = bitmap_list_new(); 1331 } else { 1332 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1333 s->bitmap_directory_size, errp); 1334 if (bm_list == NULL) { 1335 return; 1336 } 1337 } 1338 1339 /* check constraints and names */ 1340 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL; 1341 bitmap = bdrv_dirty_bitmap_next(bs, bitmap)) 1342 { 1343 const char *name = bdrv_dirty_bitmap_name(bitmap); 1344 uint32_t granularity = bdrv_dirty_bitmap_granularity(bitmap); 1345 Qcow2Bitmap *bm; 1346 1347 if (!bdrv_dirty_bitmap_get_persistance(bitmap) || 1348 bdrv_dirty_bitmap_readonly(bitmap)) 1349 { 1350 continue; 1351 } 1352 1353 if (check_constraints_on_bitmap(bs, name, granularity, errp) < 0) { 1354 error_prepend(errp, "Bitmap '%s' doesn't satisfy the constraints: ", 1355 name); 1356 goto fail; 1357 } 1358 1359 bm = find_bitmap_by_name(bm_list, name); 1360 if (bm == NULL) { 1361 if (++new_nb_bitmaps > QCOW2_MAX_BITMAPS) { 1362 error_setg(errp, "Too many persistent bitmaps"); 1363 goto fail; 1364 } 1365 1366 new_dir_size += calc_dir_entry_size(strlen(name), 0); 1367 if (new_dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { 1368 error_setg(errp, "Bitmap directory is too large"); 1369 goto fail; 1370 } 1371 1372 bm = g_new0(Qcow2Bitmap, 1); 1373 bm->name = g_strdup(name); 1374 QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry); 1375 } else { 1376 if (!(bm->flags & BME_FLAG_IN_USE)) { 1377 error_setg(errp, "Bitmap '%s' already exists in the image", 1378 name); 1379 goto fail; 1380 } 1381 tb = g_memdup(&bm->table, sizeof(bm->table)); 1382 bm->table.offset = 0; 1383 bm->table.size = 0; 1384 QSIMPLEQ_INSERT_TAIL(&drop_tables, tb, entry); 1385 } 1386 bm->flags = bdrv_dirty_bitmap_enabled(bitmap) ? BME_FLAG_AUTO : 0; 1387 bm->granularity_bits = ctz32(bdrv_dirty_bitmap_granularity(bitmap)); 1388 bm->dirty_bitmap = bitmap; 1389 } 1390 1391 /* allocate clusters and store bitmaps */ 1392 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1393 if (bm->dirty_bitmap == NULL) { 1394 continue; 1395 } 1396 1397 ret = store_bitmap(bs, bm, errp); 1398 if (ret < 0) { 1399 goto fail; 1400 } 1401 } 1402 1403 ret = update_ext_header_and_dir(bs, bm_list); 1404 if (ret < 0) { 1405 error_setg_errno(errp, -ret, "Failed to update bitmap extension"); 1406 goto fail; 1407 } 1408 1409 /* Bitmap directory was successfully updated, so, old data can be dropped. 1410 * TODO it is better to reuse these clusters */ 1411 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) { 1412 free_bitmap_clusters(bs, tb); 1413 g_free(tb); 1414 } 1415 1416 bitmap_list_free(bm_list); 1417 return; 1418 1419 fail: 1420 QSIMPLEQ_FOREACH(bm, bm_list, entry) { 1421 if (bm->dirty_bitmap == NULL || bm->table.offset == 0) { 1422 continue; 1423 } 1424 1425 free_bitmap_clusters(bs, &bm->table); 1426 } 1427 1428 QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) { 1429 g_free(tb); 1430 } 1431 1432 bitmap_list_free(bm_list); 1433 } 1434 1435 int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp) 1436 { 1437 BdrvDirtyBitmap *bitmap; 1438 Error *local_err = NULL; 1439 1440 qcow2_store_persistent_dirty_bitmaps(bs, &local_err); 1441 if (local_err != NULL) { 1442 error_propagate(errp, local_err); 1443 return -EINVAL; 1444 } 1445 1446 for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL; 1447 bitmap = bdrv_dirty_bitmap_next(bs, bitmap)) 1448 { 1449 if (bdrv_dirty_bitmap_get_persistance(bitmap)) { 1450 bdrv_dirty_bitmap_set_readonly(bitmap, true); 1451 } 1452 } 1453 1454 return 0; 1455 } 1456 1457 bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs, 1458 const char *name, 1459 uint32_t granularity, 1460 Error **errp) 1461 { 1462 BDRVQcow2State *s = bs->opaque; 1463 bool found; 1464 Qcow2BitmapList *bm_list; 1465 1466 if (s->qcow_version < 3) { 1467 /* Without autoclear_features, we would always have to assume 1468 * that a program without persistent dirty bitmap support has 1469 * accessed this qcow2 file when opening it, and would thus 1470 * have to drop all dirty bitmaps (defeating their purpose). 1471 */ 1472 error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files"); 1473 goto fail; 1474 } 1475 1476 if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) { 1477 goto fail; 1478 } 1479 1480 if (s->nb_bitmaps == 0) { 1481 return true; 1482 } 1483 1484 if (s->nb_bitmaps >= QCOW2_MAX_BITMAPS) { 1485 error_setg(errp, 1486 "Maximum number of persistent bitmaps is already reached"); 1487 goto fail; 1488 } 1489 1490 if (s->bitmap_directory_size + calc_dir_entry_size(strlen(name), 0) > 1491 QCOW2_MAX_BITMAP_DIRECTORY_SIZE) 1492 { 1493 error_setg(errp, "Not enough space in the bitmap directory"); 1494 goto fail; 1495 } 1496 1497 bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, 1498 s->bitmap_directory_size, errp); 1499 if (bm_list == NULL) { 1500 goto fail; 1501 } 1502 1503 found = find_bitmap_by_name(bm_list, name); 1504 bitmap_list_free(bm_list); 1505 if (found) { 1506 error_setg(errp, "Bitmap with the same name is already stored"); 1507 goto fail; 1508 } 1509 1510 return true; 1511 1512 fail: 1513 error_prepend(errp, "Can't make bitmap '%s' persistent in '%s': ", 1514 name, bdrv_get_device_or_node_name(bs)); 1515 return false; 1516 } 1517