block/qcow2-bitmap.c

   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         bitmap_table[i] = cpu_to_be64(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         table[i] = be64_to_cpu(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     entry->bitmap_table_offset = be64_to_cpu(entry->bitmap_table_offset);
 398     entry->bitmap_table_size = be32_to_cpu(entry->bitmap_table_size);
 399     entry->flags = be32_to_cpu(entry->flags);
 400     entry->name_size = be16_to_cpu(entry->name_size);
 401     entry->extra_data_size = be32_to_cpu(entry->extra_data_size);
 402 }
 403
 404 static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry)
 405 {
 406     entry->bitmap_table_offset = cpu_to_be64(entry->bitmap_table_offset);
 407     entry->bitmap_table_size = cpu_to_be32(entry->bitmap_table_size);
 408     entry->flags = cpu_to_be32(entry->flags);
 409     entry->name_size = cpu_to_be16(entry->name_size);
 410     entry->extra_data_size = cpu_to_be32(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     /* Actually, even in in-place case ignoring QCOW2_OL_BITMAP_DIRECTORY is not
 779      * necessary, because we drop QCOW2_AUTOCLEAR_BITMAPS when updating bitmap
 780      * directory in-place (actually, turn-off the extension), which is checked
 781      * in qcow2_check_metadata_overlap() */
 782     ret = qcow2_pre_write_overlap_check(
 783             bs, in_place ? QCOW2_OL_BITMAP_DIRECTORY : 0, dir_offset, dir_size);
 784     if (ret < 0) {
 785         goto fail;
 786     }
 787
 788     ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size);
 789     if (ret < 0) {
 790         goto fail;
 791     }
 792
 793     g_free(dir);
 794
 795     if (!in_place) {
 796         *size = dir_size;
 797         *offset = dir_offset;
 798     }
 799
 800     return 0;
 801
 802 fail:
 803     g_free(dir);
 804
 805     if (!in_place && dir_offset > 0) {
 806         qcow2_free_clusters(bs, dir_offset, dir_size, QCOW2_DISCARD_OTHER);
 807     }
 808
 809     return ret;
 810 }
 811
 812 /*
 813  * Bitmap List end
 814  */
 815
 816 static int update_ext_header_and_dir_in_place(BlockDriverState *bs,
 817                                               Qcow2BitmapList *bm_list)
 818 {
 819     BDRVQcow2State *s = bs->opaque;
 820     int ret;
 821
 822     if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS) ||
 823         bm_list == NULL || QSIMPLEQ_EMPTY(bm_list) ||
 824         bitmap_list_count(bm_list) != s->nb_bitmaps)
 825     {
 826         return -EINVAL;
 827     }
 828
 829     s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
 830     ret = update_header_sync(bs);
 831     if (ret < 0) {
 832         /* Two variants are possible here:
 833          * 1. Autoclear flag is dropped, all bitmaps will be lost.
 834          * 2. Autoclear flag is not dropped, old state is left.
 835          */
 836         return ret;
 837     }
 838
 839     /* autoclear bit is not set, so we can safely update bitmap directory */
 840
 841     ret = bitmap_list_store(bs, bm_list, &s->bitmap_directory_offset,
 842                             &s->bitmap_directory_size, true);
 843     if (ret < 0) {
 844         /* autoclear bit is cleared, so all leaked clusters would be removed on
 845          * qemu-img check */
 846         return ret;
 847     }
 848
 849     ret = update_header_sync(bs);
 850     if (ret < 0) {
 851         /* autoclear bit is cleared, so all leaked clusters would be removed on
 852          * qemu-img check */
 853         return ret;
 854     }
 855
 856     s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
 857     return update_header_sync(bs);
 858     /* If final update_header_sync() fails, two variants are possible:
 859      * 1. Autoclear flag is not set, all bitmaps will be lost.
 860      * 2. Autoclear flag is set, header and directory are successfully updated.
 861      */
 862 }
 863
 864 static int update_ext_header_and_dir(BlockDriverState *bs,
 865                                      Qcow2BitmapList *bm_list)
 866 {
 867     BDRVQcow2State *s = bs->opaque;
 868     int ret;
 869     uint64_t new_offset = 0;
 870     uint64_t new_size = 0;
 871     uint32_t new_nb_bitmaps = 0;
 872     uint64_t old_offset = s->bitmap_directory_offset;
 873     uint64_t old_size = s->bitmap_directory_size;
 874     uint32_t old_nb_bitmaps = s->nb_bitmaps;
 875     uint64_t old_autocl = s->autoclear_features;
 876
 877     if (bm_list != NULL && !QSIMPLEQ_EMPTY(bm_list)) {
 878         new_nb_bitmaps = bitmap_list_count(bm_list);
 879
 880         if (new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
 881             return -EINVAL;
 882         }
 883
 884         ret = bitmap_list_store(bs, bm_list, &new_offset, &new_size, false);
 885         if (ret < 0) {
 886             return ret;
 887         }
 888
 889         ret = qcow2_flush_caches(bs);
 890         if (ret < 0) {
 891             goto fail;
 892         }
 893
 894         s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
 895     } else {
 896         s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
 897     }
 898
 899     s->bitmap_directory_offset = new_offset;
 900     s->bitmap_directory_size = new_size;
 901     s->nb_bitmaps = new_nb_bitmaps;
 902
 903     ret = update_header_sync(bs);
 904     if (ret < 0) {
 905         goto fail;
 906     }
 907
 908     if (old_size > 0) {
 909         qcow2_free_clusters(bs, old_offset, old_size, QCOW2_DISCARD_OTHER);
 910     }
 911
 912     return 0;
 913
 914 fail:
 915     if (new_offset > 0) {
 916         qcow2_free_clusters(bs, new_offset, new_size, QCOW2_DISCARD_OTHER);
 917     }
 918
 919     s->bitmap_directory_offset = old_offset;
 920     s->bitmap_directory_size = old_size;
 921     s->nb_bitmaps = old_nb_bitmaps;
 922     s->autoclear_features = old_autocl;
 923
 924     return ret;
 925 }
 926
 927 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
 928 static void release_dirty_bitmap_helper(gpointer bitmap,
 929                                         gpointer bs)
 930 {
 931     bdrv_release_dirty_bitmap(bs, bitmap);
 932 }
 933
 934 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
 935 static void set_readonly_helper(gpointer bitmap, gpointer value)
 936 {
 937     bdrv_dirty_bitmap_set_readonly(bitmap, (bool)value);
 938 }
 939
 940 /* qcow2_load_dirty_bitmaps()
 941  * Return value is a hint for caller: true means that the Qcow2 header was
 942  * updated. (false doesn't mean that the header should be updated by the
 943  * caller, it just means that updating was not needed or the image cannot be
 944  * written to).
 945  * On failure the function returns false.
 946  */
 947 bool qcow2_load_dirty_bitmaps(BlockDriverState *bs, Error **errp)
 948 {
 949     BDRVQcow2State *s = bs->opaque;
 950     Qcow2BitmapList *bm_list;
 951     Qcow2Bitmap *bm;
 952     GSList *created_dirty_bitmaps = NULL;
 953     bool header_updated = false;
 954
 955     if (s->nb_bitmaps == 0) {
 956         /* No bitmaps - nothing to do */
 957         return false;
 958     }
 959
 960     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
 961                                s->bitmap_directory_size, errp);
 962     if (bm_list == NULL) {
 963         return false;
 964     }
 965
 966     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
 967         if (!(bm->flags & BME_FLAG_IN_USE)) {
 968             BdrvDirtyBitmap *bitmap = load_bitmap(bs, bm, errp);
 969             if (bitmap == NULL) {
 970                 goto fail;
 971             }
 972
 973             if (!(bm->flags & BME_FLAG_AUTO)) {
 974                 bdrv_disable_dirty_bitmap(bitmap);
 975             }
 976             bdrv_dirty_bitmap_set_persistance(bitmap, true);
 977             bm->flags |= BME_FLAG_IN_USE;
 978             created_dirty_bitmaps =
 979                     g_slist_append(created_dirty_bitmaps, bitmap);
 980         }
 981     }
 982
 983     if (created_dirty_bitmaps != NULL) {
 984         if (can_write(bs)) {
 985             /* in_use flags must be updated */
 986             int ret = update_ext_header_and_dir_in_place(bs, bm_list);
 987             if (ret < 0) {
 988                 error_setg_errno(errp, -ret, "Can't update bitmap directory");
 989                 goto fail;
 990             }
 991             header_updated = true;
 992         } else {
 993             g_slist_foreach(created_dirty_bitmaps, set_readonly_helper,
 994                             (gpointer)true);
 995         }
 996     }
 997
 998     g_slist_free(created_dirty_bitmaps);
 999     bitmap_list_free(bm_list);
1000
1001     return header_updated;
1002
1003 fail:
1004     g_slist_foreach(created_dirty_bitmaps, release_dirty_bitmap_helper, bs);
1005     g_slist_free(created_dirty_bitmaps);
1006     bitmap_list_free(bm_list);
1007
1008     return false;
1009 }
1010
1011 int qcow2_reopen_bitmaps_rw_hint(BlockDriverState *bs, bool *header_updated,
1012                                  Error **errp)
1013 {
1014     BDRVQcow2State *s = bs->opaque;
1015     Qcow2BitmapList *bm_list;
1016     Qcow2Bitmap *bm;
1017     GSList *ro_dirty_bitmaps = NULL;
1018     int ret = 0;
1019
1020     if (header_updated != NULL) {
1021         *header_updated = false;
1022     }
1023
1024     if (s->nb_bitmaps == 0) {
1025         /* No bitmaps - nothing to do */
1026         return 0;
1027     }
1028
1029     if (!can_write(bs)) {
1030         error_setg(errp, "Can't write to the image on reopening bitmaps rw");
1031         return -EINVAL;
1032     }
1033
1034     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1035                                s->bitmap_directory_size, errp);
1036     if (bm_list == NULL) {
1037         return -EINVAL;
1038     }
1039
1040     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1041         if (!(bm->flags & BME_FLAG_IN_USE)) {
1042             BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name);
1043             if (bitmap == NULL) {
1044                 continue;
1045             }
1046
1047             if (!bdrv_dirty_bitmap_readonly(bitmap)) {
1048                 error_setg(errp, "Bitmap %s is not readonly but not marked"
1049                                  "'IN_USE' in the image. Something went wrong,"
1050                                  "all the bitmaps may be corrupted", bm->name);
1051                 ret = -EINVAL;
1052                 goto out;
1053             }
1054
1055             bm->flags |= BME_FLAG_IN_USE;
1056             ro_dirty_bitmaps = g_slist_append(ro_dirty_bitmaps, bitmap);
1057         }
1058     }
1059
1060     if (ro_dirty_bitmaps != NULL) {
1061         /* in_use flags must be updated */
1062         ret = update_ext_header_and_dir_in_place(bs, bm_list);
1063         if (ret < 0) {
1064             error_setg_errno(errp, -ret, "Can't update bitmap directory");
1065             goto out;
1066         }
1067         if (header_updated != NULL) {
1068             *header_updated = true;
1069         }
1070         g_slist_foreach(ro_dirty_bitmaps, set_readonly_helper, false);
1071     }
1072
1073 out:
1074     g_slist_free(ro_dirty_bitmaps);
1075     bitmap_list_free(bm_list);
1076
1077     return ret;
1078 }
1079
1080 int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp)
1081 {
1082     return qcow2_reopen_bitmaps_rw_hint(bs, NULL, errp);
1083 }
1084
1085 /* store_bitmap_data()
1086  * Store bitmap to image, filling bitmap table accordingly.
1087  */
1088 static uint64_t *store_bitmap_data(BlockDriverState *bs,
1089                                    BdrvDirtyBitmap *bitmap,
1090                                    uint32_t *bitmap_table_size, Error **errp)
1091 {
1092     int ret;
1093     BDRVQcow2State *s = bs->opaque;
1094     int64_t offset;
1095     uint64_t limit;
1096     uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
1097     const char *bm_name = bdrv_dirty_bitmap_name(bitmap);
1098     uint8_t *buf = NULL;
1099     BdrvDirtyBitmapIter *dbi;
1100     uint64_t *tb;
1101     uint64_t tb_size =
1102             size_to_clusters(s,
1103                 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
1104
1105     if (tb_size > BME_MAX_TABLE_SIZE ||
1106         tb_size * s->cluster_size > BME_MAX_PHYS_SIZE)
1107     {
1108         error_setg(errp, "Bitmap '%s' is too big", bm_name);
1109         return NULL;
1110     }
1111
1112     tb = g_try_new0(uint64_t, tb_size);
1113     if (tb == NULL) {
1114         error_setg(errp, "No memory");
1115         return NULL;
1116     }
1117
1118     dbi = bdrv_dirty_iter_new(bitmap);
1119     buf = g_malloc(s->cluster_size);
1120     limit = bytes_covered_by_bitmap_cluster(s, bitmap);
1121     assert(DIV_ROUND_UP(bm_size, limit) == tb_size);
1122
1123     while ((offset = bdrv_dirty_iter_next(dbi)) >= 0) {
1124         uint64_t cluster = offset / limit;
1125         uint64_t end, write_size;
1126         int64_t off;
1127
1128         /*
1129          * We found the first dirty offset, but want to write out the
1130          * entire cluster of the bitmap that includes that offset,
1131          * including any leading zero bits.
1132          */
1133         offset = QEMU_ALIGN_DOWN(offset, limit);
1134         end = MIN(bm_size, offset + limit);
1135         write_size = bdrv_dirty_bitmap_serialization_size(bitmap, offset,
1136                                                           end - offset);
1137         assert(write_size <= s->cluster_size);
1138
1139         off = qcow2_alloc_clusters(bs, s->cluster_size);
1140         if (off < 0) {
1141             error_setg_errno(errp, -off,
1142                              "Failed to allocate clusters for bitmap '%s'",
1143                              bm_name);
1144             goto fail;
1145         }
1146         tb[cluster] = off;
1147
1148         bdrv_dirty_bitmap_serialize_part(bitmap, buf, offset, end - offset);
1149         if (write_size < s->cluster_size) {
1150             memset(buf + write_size, 0, s->cluster_size - write_size);
1151         }
1152
1153         ret = qcow2_pre_write_overlap_check(bs, 0, off, s->cluster_size);
1154         if (ret < 0) {
1155             error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1156             goto fail;
1157         }
1158
1159         ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size);
1160         if (ret < 0) {
1161             error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1162                              bm_name);
1163             goto fail;
1164         }
1165
1166         if (end >= bm_size) {
1167             break;
1168         }
1169
1170         bdrv_set_dirty_iter(dbi, end);
1171     }
1172
1173     *bitmap_table_size = tb_size;
1174     g_free(buf);
1175     bdrv_dirty_iter_free(dbi);
1176
1177     return tb;
1178
1179 fail:
1180     clear_bitmap_table(bs, tb, tb_size);
1181     g_free(buf);
1182     bdrv_dirty_iter_free(dbi);
1183     g_free(tb);
1184
1185     return NULL;
1186 }
1187
1188 /* store_bitmap()
1189  * Store bm->dirty_bitmap to qcow2.
1190  * Set bm->table_offset and bm->table_size accordingly.
1191  */
1192 static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
1193 {
1194     int ret;
1195     uint64_t *tb;
1196     int64_t tb_offset;
1197     uint32_t tb_size;
1198     BdrvDirtyBitmap *bitmap = bm->dirty_bitmap;
1199     const char *bm_name;
1200
1201     assert(bitmap != NULL);
1202
1203     bm_name = bdrv_dirty_bitmap_name(bitmap);
1204
1205     tb = store_bitmap_data(bs, bitmap, &tb_size, errp);
1206     if (tb == NULL) {
1207         return -EINVAL;
1208     }
1209
1210     assert(tb_size <= BME_MAX_TABLE_SIZE);
1211     tb_offset = qcow2_alloc_clusters(bs, tb_size * sizeof(tb[0]));
1212     if (tb_offset < 0) {
1213         error_setg_errno(errp, -tb_offset,
1214                          "Failed to allocate clusters for bitmap '%s'",
1215                          bm_name);
1216         ret = tb_offset;
1217         goto fail;
1218     }
1219
1220     ret = qcow2_pre_write_overlap_check(bs, 0, tb_offset,
1221                                         tb_size * sizeof(tb[0]));
1222     if (ret < 0) {
1223         error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1224         goto fail;
1225     }
1226
1227     bitmap_table_to_be(tb, tb_size);
1228     ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]));
1229     if (ret < 0) {
1230         error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1231                          bm_name);
1232         goto fail;
1233     }
1234
1235     g_free(tb);
1236
1237     bm->table.offset = tb_offset;
1238     bm->table.size = tb_size;
1239
1240     return 0;
1241
1242 fail:
1243     clear_bitmap_table(bs, tb, tb_size);
1244
1245     if (tb_offset > 0) {
1246         qcow2_free_clusters(bs, tb_offset, tb_size * sizeof(tb[0]),
1247                             QCOW2_DISCARD_OTHER);
1248     }
1249
1250     g_free(tb);
1251
1252     return ret;
1253 }
1254
1255 static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,
1256                                         const char *name)
1257 {
1258     Qcow2Bitmap *bm;
1259
1260     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1261         if (strcmp(name, bm->name) == 0) {
1262             return bm;
1263         }
1264     }
1265
1266     return NULL;
1267 }
1268
1269 void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs,
1270                                           const char *name,
1271                                           Error **errp)
1272 {
1273     int ret;
1274     BDRVQcow2State *s = bs->opaque;
1275     Qcow2Bitmap *bm;
1276     Qcow2BitmapList *bm_list;
1277
1278     if (s->nb_bitmaps == 0) {
1279         /* Absence of the bitmap is not an error: see explanation above
1280          * bdrv_remove_persistent_dirty_bitmap() definition. */
1281         return;
1282     }
1283
1284     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1285                                s->bitmap_directory_size, errp);
1286     if (bm_list == NULL) {
1287         return;
1288     }
1289
1290     bm = find_bitmap_by_name(bm_list, name);
1291     if (bm == NULL) {
1292         goto fail;
1293     }
1294
1295     QSIMPLEQ_REMOVE(bm_list, bm, Qcow2Bitmap, entry);
1296
1297     ret = update_ext_header_and_dir(bs, bm_list);
1298     if (ret < 0) {
1299         error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1300         goto fail;
1301     }
1302
1303     free_bitmap_clusters(bs, &bm->table);
1304
1305 fail:
1306     bitmap_free(bm);
1307     bitmap_list_free(bm_list);
1308 }
1309
1310 void qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs, Error **errp)
1311 {
1312     BdrvDirtyBitmap *bitmap;
1313     BDRVQcow2State *s = bs->opaque;
1314     uint32_t new_nb_bitmaps = s->nb_bitmaps;
1315     uint64_t new_dir_size = s->bitmap_directory_size;
1316     int ret;
1317     Qcow2BitmapList *bm_list;
1318     Qcow2Bitmap *bm;
1319     Qcow2BitmapTableList drop_tables;
1320     Qcow2BitmapTable *tb, *tb_next;
1321
1322     if (!bdrv_has_changed_persistent_bitmaps(bs)) {
1323         /* nothing to do */
1324         return;
1325     }
1326
1327     if (!can_write(bs)) {
1328         error_setg(errp, "No write access");
1329         return;
1330     }
1331
1332     QSIMPLEQ_INIT(&drop_tables);
1333
1334     if (s->nb_bitmaps == 0) {
1335         bm_list = bitmap_list_new();
1336     } else {
1337         bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1338                                    s->bitmap_directory_size, errp);
1339         if (bm_list == NULL) {
1340             return;
1341         }
1342     }
1343
1344     /* check constraints and names */
1345     for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL;
1346          bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
1347     {
1348         const char *name = bdrv_dirty_bitmap_name(bitmap);
1349         uint32_t granularity = bdrv_dirty_bitmap_granularity(bitmap);
1350         Qcow2Bitmap *bm;
1351
1352         if (!bdrv_dirty_bitmap_get_persistance(bitmap) ||
1353             bdrv_dirty_bitmap_readonly(bitmap))
1354         {
1355             continue;
1356         }
1357
1358         if (check_constraints_on_bitmap(bs, name, granularity, errp) < 0) {
1359             error_prepend(errp, "Bitmap '%s' doesn't satisfy the constraints: ",
1360                           name);
1361             goto fail;
1362         }
1363
1364         bm = find_bitmap_by_name(bm_list, name);
1365         if (bm == NULL) {
1366             if (++new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
1367                 error_setg(errp, "Too many persistent bitmaps");
1368                 goto fail;
1369             }
1370
1371             new_dir_size += calc_dir_entry_size(strlen(name), 0);
1372             if (new_dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
1373                 error_setg(errp, "Bitmap directory is too large");
1374                 goto fail;
1375             }
1376
1377             bm = g_new0(Qcow2Bitmap, 1);
1378             bm->name = g_strdup(name);
1379             QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry);
1380         } else {
1381             if (!(bm->flags & BME_FLAG_IN_USE)) {
1382                 error_setg(errp, "Bitmap '%s' already exists in the image",
1383                            name);
1384                 goto fail;
1385             }
1386             tb = g_memdup(&bm->table, sizeof(bm->table));
1387             bm->table.offset = 0;
1388             bm->table.size = 0;
1389             QSIMPLEQ_INSERT_TAIL(&drop_tables, tb, entry);
1390         }
1391         bm->flags = bdrv_dirty_bitmap_enabled(bitmap) ? BME_FLAG_AUTO : 0;
1392         bm->granularity_bits = ctz32(bdrv_dirty_bitmap_granularity(bitmap));
1393         bm->dirty_bitmap = bitmap;
1394     }
1395
1396     /* allocate clusters and store bitmaps */
1397     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1398         if (bm->dirty_bitmap == NULL) {
1399             continue;
1400         }
1401
1402         ret = store_bitmap(bs, bm, errp);
1403         if (ret < 0) {
1404             goto fail;
1405         }
1406     }
1407
1408     ret = update_ext_header_and_dir(bs, bm_list);
1409     if (ret < 0) {
1410         error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1411         goto fail;
1412     }
1413
1414     /* Bitmap directory was successfully updated, so, old data can be dropped.
1415      * TODO it is better to reuse these clusters */
1416     QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1417         free_bitmap_clusters(bs, tb);
1418         g_free(tb);
1419     }
1420
1421     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1422         /* For safety, we remove bitmap after storing.
1423          * We may be here in two cases:
1424          * 1. bdrv_close. It's ok to drop bitmap.
1425          * 2. inactivation. It means migration without 'dirty-bitmaps'
1426          *    capability, so bitmaps are not marked with
1427          *    BdrvDirtyBitmap.migration flags. It's not bad to drop them too,
1428          *    and reload on invalidation.
1429          */
1430         if (bm->dirty_bitmap == NULL) {
1431             continue;
1432         }
1433
1434         bdrv_release_dirty_bitmap(bs, bm->dirty_bitmap);
1435     }
1436
1437     bitmap_list_free(bm_list);
1438     return;
1439
1440 fail:
1441     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1442         if (bm->dirty_bitmap == NULL || bm->table.offset == 0) {
1443             continue;
1444         }
1445
1446         free_bitmap_clusters(bs, &bm->table);
1447     }
1448
1449     QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1450         g_free(tb);
1451     }
1452
1453     bitmap_list_free(bm_list);
1454 }
1455
1456 int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp)
1457 {
1458     BdrvDirtyBitmap *bitmap;
1459     Error *local_err = NULL;
1460
1461     qcow2_store_persistent_dirty_bitmaps(bs, &local_err);
1462     if (local_err != NULL) {
1463         error_propagate(errp, local_err);
1464         return -EINVAL;
1465     }
1466
1467     for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap != NULL;
1468          bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
1469     {
1470         if (bdrv_dirty_bitmap_get_persistance(bitmap)) {
1471             bdrv_dirty_bitmap_set_readonly(bitmap, true);
1472         }
1473     }
1474
1475     return 0;
1476 }
1477
1478 bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,
1479                                       const char *name,
1480                                       uint32_t granularity,
1481                                       Error **errp)
1482 {
1483     BDRVQcow2State *s = bs->opaque;
1484     bool found;
1485     Qcow2BitmapList *bm_list;
1486
1487     if (s->qcow_version < 3) {
1488         /* Without autoclear_features, we would always have to assume
1489          * that a program without persistent dirty bitmap support has
1490          * accessed this qcow2 file when opening it, and would thus
1491          * have to drop all dirty bitmaps (defeating their purpose).
1492          */
1493         error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files");
1494         goto fail;
1495     }
1496
1497     if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) {
1498         goto fail;
1499     }
1500
1501     if (s->nb_bitmaps == 0) {
1502         return true;
1503     }
1504
1505     if (s->nb_bitmaps >= QCOW2_MAX_BITMAPS) {
1506         error_setg(errp,
1507                    "Maximum number of persistent bitmaps is already reached");
1508         goto fail;
1509     }
1510
1511     if (s->bitmap_directory_size + calc_dir_entry_size(strlen(name), 0) >
1512         QCOW2_MAX_BITMAP_DIRECTORY_SIZE)
1513     {
1514         error_setg(errp, "Not enough space in the bitmap directory");
1515         goto fail;
1516     }
1517
1518     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1519                                s->bitmap_directory_size, errp);
1520     if (bm_list == NULL) {
1521         goto fail;
1522     }
1523
1524     found = find_bitmap_by_name(bm_list, name);
1525     bitmap_list_free(bm_list);
1526     if (found) {
1527         error_setg(errp, "Bitmap with the same name is already stored");
1528         goto fail;
1529     }
1530
1531     return true;
1532
1533 fail:
1534     error_prepend(errp, "Can't make bitmap '%s' persistent in '%s': ",
1535                   name, bdrv_get_device_or_node_name(bs));
1536     return false;
1537 }