xref: /openbmc/qemu/block/qcow2-bitmap.c (revision f9cc8cfd)
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 "block/block-io.h"
30 #include "block/dirty-bitmap.h"
31 #include "qapi/error.h"
32 #include "qemu/cutils.h"
33 
34 #include "qcow2.h"
35 
36 /* NOTICE: BME here means Bitmaps Extension and used as a namespace for
37  * _internal_ constants. Please do not use this _internal_ abbreviation for
38  * other needs and/or outside of this file. */
39 
40 /* Bitmap directory entry constraints */
41 #define BME_MAX_TABLE_SIZE 0x8000000
42 #define BME_MAX_PHYS_SIZE 0x20000000 /* restrict BdrvDirtyBitmap size in RAM */
43 #define BME_MAX_GRANULARITY_BITS 31
44 #define BME_MIN_GRANULARITY_BITS 9
45 #define BME_MAX_NAME_SIZE 1023
46 
47 /* Size of bitmap table entries */
48 #define BME_TABLE_ENTRY_SIZE (sizeof(uint64_t))
49 
50 QEMU_BUILD_BUG_ON(BME_MAX_NAME_SIZE != BDRV_BITMAP_MAX_NAME_SIZE);
51 
52 #if BME_MAX_TABLE_SIZE * 8ULL > INT_MAX
53 #error In the code bitmap table physical size assumed to fit into int
54 #endif
55 
56 /* Bitmap directory entry flags */
57 #define BME_RESERVED_FLAGS 0xfffffffcU
58 #define BME_FLAG_IN_USE (1U << 0)
59 #define BME_FLAG_AUTO   (1U << 1)
60 
61 /* bits [1, 8] U [56, 63] are reserved */
62 #define BME_TABLE_ENTRY_RESERVED_MASK 0xff000000000001feULL
63 #define BME_TABLE_ENTRY_OFFSET_MASK 0x00fffffffffffe00ULL
64 #define BME_TABLE_ENTRY_FLAG_ALL_ONES (1ULL << 0)
65 
66 typedef struct QEMU_PACKED Qcow2BitmapDirEntry {
67     /* header is 8 byte aligned */
68     uint64_t bitmap_table_offset;
69 
70     uint32_t bitmap_table_size;
71     uint32_t flags;
72 
73     uint8_t type;
74     uint8_t granularity_bits;
75     uint16_t name_size;
76     uint32_t extra_data_size;
77     /* extra data follows  */
78     /* name follows  */
79 } Qcow2BitmapDirEntry;
80 
81 typedef struct Qcow2BitmapTable {
82     uint64_t offset;
83     uint32_t size; /* number of 64bit entries */
84     QSIMPLEQ_ENTRY(Qcow2BitmapTable) entry;
85 } Qcow2BitmapTable;
86 
87 typedef struct Qcow2Bitmap {
88     Qcow2BitmapTable table;
89     uint32_t flags;
90     uint8_t granularity_bits;
91     char *name;
92 
93     BdrvDirtyBitmap *dirty_bitmap;
94 
95     QSIMPLEQ_ENTRY(Qcow2Bitmap) entry;
96 } Qcow2Bitmap;
97 typedef QSIMPLEQ_HEAD(Qcow2BitmapList, Qcow2Bitmap) Qcow2BitmapList;
98 
99 typedef enum BitmapType {
100     BT_DIRTY_TRACKING_BITMAP = 1
101 } BitmapType;
102 
can_write(BlockDriverState * bs)103 static inline bool can_write(BlockDriverState *bs)
104 {
105     return !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);
106 }
107 
update_header_sync(BlockDriverState * bs)108 static int GRAPH_RDLOCK update_header_sync(BlockDriverState *bs)
109 {
110     int ret;
111 
112     ret = qcow2_update_header(bs);
113     if (ret < 0) {
114         return ret;
115     }
116 
117     return bdrv_flush(bs->file->bs);
118 }
119 
bitmap_table_bswap_be(uint64_t * bitmap_table,size_t size)120 static inline void bitmap_table_bswap_be(uint64_t *bitmap_table, size_t size)
121 {
122     size_t i;
123 
124     for (i = 0; i < size; ++i) {
125         bitmap_table[i] = cpu_to_be64(bitmap_table[i]);
126     }
127 }
128 
check_table_entry(uint64_t entry,int cluster_size)129 static int check_table_entry(uint64_t entry, int cluster_size)
130 {
131     uint64_t offset;
132 
133     if (entry & BME_TABLE_ENTRY_RESERVED_MASK) {
134         return -EINVAL;
135     }
136 
137     offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
138     if (offset != 0) {
139         /* if offset specified, bit 0 is reserved */
140         if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) {
141             return -EINVAL;
142         }
143 
144         if (offset % cluster_size != 0) {
145             return -EINVAL;
146         }
147     }
148 
149     return 0;
150 }
151 
get_bitmap_bytes_needed(int64_t len,uint32_t granularity)152 static int64_t get_bitmap_bytes_needed(int64_t len, uint32_t granularity)
153 {
154     int64_t num_bits = DIV_ROUND_UP(len, granularity);
155 
156     return DIV_ROUND_UP(num_bits, 8);
157 }
158 
159 static int GRAPH_RDLOCK
check_constraints_on_bitmap(BlockDriverState * bs,const char * name,uint32_t granularity,Error ** errp)160 check_constraints_on_bitmap(BlockDriverState *bs, const char *name,
161                             uint32_t granularity, Error **errp)
162 {
163     BDRVQcow2State *s = bs->opaque;
164     int granularity_bits = ctz32(granularity);
165     int64_t len = bdrv_getlength(bs);
166     int64_t bitmap_bytes;
167 
168     assert(granularity > 0);
169     assert((granularity & (granularity - 1)) == 0);
170 
171     if (len < 0) {
172         error_setg_errno(errp, -len, "Failed to get size of '%s'",
173                          bdrv_get_device_or_node_name(bs));
174         return len;
175     }
176 
177     if (granularity_bits > BME_MAX_GRANULARITY_BITS) {
178         error_setg(errp, "Granularity exceeds maximum (%llu bytes)",
179                    1ULL << BME_MAX_GRANULARITY_BITS);
180         return -EINVAL;
181     }
182     if (granularity_bits < BME_MIN_GRANULARITY_BITS) {
183         error_setg(errp, "Granularity is under minimum (%llu bytes)",
184                    1ULL << BME_MIN_GRANULARITY_BITS);
185         return -EINVAL;
186     }
187 
188     bitmap_bytes = get_bitmap_bytes_needed(len, granularity);
189     if ((bitmap_bytes > (uint64_t)BME_MAX_PHYS_SIZE) ||
190         (bitmap_bytes > (uint64_t)BME_MAX_TABLE_SIZE * s->cluster_size))
191     {
192         error_setg(errp, "Too much space will be occupied by the bitmap. "
193                    "Use larger granularity");
194         return -EINVAL;
195     }
196 
197     if (strlen(name) > BME_MAX_NAME_SIZE) {
198         error_setg(errp, "Name length exceeds maximum (%u characters)",
199                    BME_MAX_NAME_SIZE);
200         return -EINVAL;
201     }
202 
203     return 0;
204 }
205 
206 static void GRAPH_RDLOCK
clear_bitmap_table(BlockDriverState * bs,uint64_t * bitmap_table,uint32_t bitmap_table_size)207 clear_bitmap_table(BlockDriverState *bs, uint64_t *bitmap_table,
208                    uint32_t bitmap_table_size)
209 {
210     BDRVQcow2State *s = bs->opaque;
211     int i;
212 
213     for (i = 0; i < bitmap_table_size; ++i) {
214         uint64_t addr = bitmap_table[i] & BME_TABLE_ENTRY_OFFSET_MASK;
215         if (!addr) {
216             continue;
217         }
218 
219         qcow2_free_clusters(bs, addr, s->cluster_size, QCOW2_DISCARD_ALWAYS);
220         bitmap_table[i] = 0;
221     }
222 }
223 
224 static int GRAPH_RDLOCK
bitmap_table_load(BlockDriverState * bs,Qcow2BitmapTable * tb,uint64_t ** bitmap_table)225 bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
226                   uint64_t **bitmap_table)
227 {
228     int ret;
229     BDRVQcow2State *s = bs->opaque;
230     uint32_t i;
231     uint64_t *table;
232 
233     assert(tb->size != 0);
234     table = g_try_new(uint64_t, tb->size);
235     if (table == NULL) {
236         return -ENOMEM;
237     }
238 
239     assert(tb->size <= BME_MAX_TABLE_SIZE);
240     ret = bdrv_pread(bs->file, tb->offset, tb->size * BME_TABLE_ENTRY_SIZE,
241                      table, 0);
242     if (ret < 0) {
243         goto fail;
244     }
245 
246     for (i = 0; i < tb->size; ++i) {
247         table[i] = be64_to_cpu(table[i]);
248         ret = check_table_entry(table[i], s->cluster_size);
249         if (ret < 0) {
250             goto fail;
251         }
252     }
253 
254     *bitmap_table = table;
255     return 0;
256 
257 fail:
258     g_free(table);
259 
260     return ret;
261 }
262 
263 static int GRAPH_RDLOCK
free_bitmap_clusters(BlockDriverState * bs,Qcow2BitmapTable * tb)264 free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb)
265 {
266     int ret;
267     uint64_t *bitmap_table;
268 
269     ret = bitmap_table_load(bs, tb, &bitmap_table);
270     if (ret < 0) {
271         return ret;
272     }
273 
274     clear_bitmap_table(bs, bitmap_table, tb->size);
275     qcow2_free_clusters(bs, tb->offset, tb->size * BME_TABLE_ENTRY_SIZE,
276                         QCOW2_DISCARD_OTHER);
277     g_free(bitmap_table);
278 
279     tb->offset = 0;
280     tb->size = 0;
281 
282     return 0;
283 }
284 
285 /* load_bitmap_data
286  * @bitmap_table entries must satisfy specification constraints.
287  * @bitmap must be cleared */
288 static int coroutine_fn GRAPH_RDLOCK
load_bitmap_data(BlockDriverState * bs,const uint64_t * bitmap_table,uint32_t bitmap_table_size,BdrvDirtyBitmap * bitmap)289 load_bitmap_data(BlockDriverState *bs, const uint64_t *bitmap_table,
290                  uint32_t bitmap_table_size, BdrvDirtyBitmap *bitmap)
291 {
292     int ret = 0;
293     BDRVQcow2State *s = bs->opaque;
294     uint64_t offset, limit;
295     uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
296     uint8_t *buf = NULL;
297     uint64_t i, tab_size =
298             size_to_clusters(s,
299                 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
300 
301     if (tab_size != bitmap_table_size || tab_size > BME_MAX_TABLE_SIZE) {
302         return -EINVAL;
303     }
304 
305     buf = g_malloc(s->cluster_size);
306     limit = bdrv_dirty_bitmap_serialization_coverage(s->cluster_size, bitmap);
307     for (i = 0, offset = 0; i < tab_size; ++i, offset += limit) {
308         uint64_t count = MIN(bm_size - offset, limit);
309         uint64_t entry = bitmap_table[i];
310         uint64_t data_offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
311 
312         assert(check_table_entry(entry, s->cluster_size) == 0);
313 
314         if (data_offset == 0) {
315             if (entry & BME_TABLE_ENTRY_FLAG_ALL_ONES) {
316                 bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count,
317                                                    false);
318             } else {
319                 /* No need to deserialize zeros because the dirty bitmap is
320                  * already cleared */
321             }
322         } else {
323             ret = bdrv_co_pread(bs->file, data_offset, s->cluster_size, buf, 0);
324             if (ret < 0) {
325                 goto finish;
326             }
327             bdrv_dirty_bitmap_deserialize_part(bitmap, buf, offset, count,
328                                                false);
329         }
330     }
331     ret = 0;
332 
333     bdrv_dirty_bitmap_deserialize_finish(bitmap);
334 
335 finish:
336     g_free(buf);
337 
338     return ret;
339 }
340 
341 static coroutine_fn GRAPH_RDLOCK
load_bitmap(BlockDriverState * bs,Qcow2Bitmap * bm,Error ** errp)342 BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
343                              Qcow2Bitmap *bm, Error **errp)
344 {
345     int ret;
346     uint64_t *bitmap_table = NULL;
347     uint32_t granularity;
348     BdrvDirtyBitmap *bitmap = NULL;
349 
350     granularity = 1U << bm->granularity_bits;
351     bitmap = bdrv_create_dirty_bitmap(bs, granularity, bm->name, errp);
352     if (bitmap == NULL) {
353         goto fail;
354     }
355 
356     if (bm->flags & BME_FLAG_IN_USE) {
357         /* Data is unusable, skip loading it */
358         return bitmap;
359     }
360 
361     ret = bitmap_table_load(bs, &bm->table, &bitmap_table);
362     if (ret < 0) {
363         error_setg_errno(errp, -ret,
364                          "Could not read bitmap_table table from image for "
365                          "bitmap '%s'", bm->name);
366         goto fail;
367     }
368 
369     ret = load_bitmap_data(bs, bitmap_table, bm->table.size, bitmap);
370     if (ret < 0) {
371         error_setg_errno(errp, -ret, "Could not read bitmap '%s' from image",
372                          bm->name);
373         goto fail;
374     }
375 
376     g_free(bitmap_table);
377     return bitmap;
378 
379 fail:
380     g_free(bitmap_table);
381     if (bitmap != NULL) {
382         bdrv_release_dirty_bitmap(bitmap);
383     }
384 
385     return NULL;
386 }
387 
388 /*
389  * Bitmap List
390  */
391 
392 /*
393  * Bitmap List private functions
394  * Only Bitmap List knows about bitmap directory structure in Qcow2.
395  */
396 
bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry * entry)397 static inline void bitmap_dir_entry_to_cpu(Qcow2BitmapDirEntry *entry)
398 {
399     entry->bitmap_table_offset = be64_to_cpu(entry->bitmap_table_offset);
400     entry->bitmap_table_size = be32_to_cpu(entry->bitmap_table_size);
401     entry->flags = be32_to_cpu(entry->flags);
402     entry->name_size = be16_to_cpu(entry->name_size);
403     entry->extra_data_size = be32_to_cpu(entry->extra_data_size);
404 }
405 
bitmap_dir_entry_to_be(Qcow2BitmapDirEntry * entry)406 static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry)
407 {
408     entry->bitmap_table_offset = cpu_to_be64(entry->bitmap_table_offset);
409     entry->bitmap_table_size = cpu_to_be32(entry->bitmap_table_size);
410     entry->flags = cpu_to_be32(entry->flags);
411     entry->name_size = cpu_to_be16(entry->name_size);
412     entry->extra_data_size = cpu_to_be32(entry->extra_data_size);
413 }
414 
calc_dir_entry_size(size_t name_size,size_t extra_data_size)415 static inline int calc_dir_entry_size(size_t name_size, size_t extra_data_size)
416 {
417     int size = sizeof(Qcow2BitmapDirEntry) + name_size + extra_data_size;
418     return ROUND_UP(size, 8);
419 }
420 
dir_entry_size(Qcow2BitmapDirEntry * entry)421 static inline int dir_entry_size(Qcow2BitmapDirEntry *entry)
422 {
423     return calc_dir_entry_size(entry->name_size, entry->extra_data_size);
424 }
425 
dir_entry_name_field(Qcow2BitmapDirEntry * entry)426 static inline const char *dir_entry_name_field(Qcow2BitmapDirEntry *entry)
427 {
428     return (const char *)(entry + 1) + entry->extra_data_size;
429 }
430 
dir_entry_copy_name(Qcow2BitmapDirEntry * entry)431 static inline char *dir_entry_copy_name(Qcow2BitmapDirEntry *entry)
432 {
433     const char *name_field = dir_entry_name_field(entry);
434     return g_strndup(name_field, entry->name_size);
435 }
436 
next_dir_entry(Qcow2BitmapDirEntry * entry)437 static inline Qcow2BitmapDirEntry *next_dir_entry(Qcow2BitmapDirEntry *entry)
438 {
439     return (Qcow2BitmapDirEntry *)((uint8_t *)entry + dir_entry_size(entry));
440 }
441 
check_dir_entry(BlockDriverState * bs,Qcow2BitmapDirEntry * entry)442 static int check_dir_entry(BlockDriverState *bs, Qcow2BitmapDirEntry *entry)
443 {
444     BDRVQcow2State *s = bs->opaque;
445     uint64_t phys_bitmap_bytes;
446     int64_t len;
447 
448     bool fail = (entry->bitmap_table_size == 0) ||
449                 (entry->bitmap_table_offset == 0) ||
450                 (entry->bitmap_table_offset % s->cluster_size) ||
451                 (entry->bitmap_table_size > BME_MAX_TABLE_SIZE) ||
452                 (entry->granularity_bits > BME_MAX_GRANULARITY_BITS) ||
453                 (entry->granularity_bits < BME_MIN_GRANULARITY_BITS) ||
454                 (entry->flags & BME_RESERVED_FLAGS) ||
455                 (entry->name_size > BME_MAX_NAME_SIZE) ||
456                 (entry->type != BT_DIRTY_TRACKING_BITMAP);
457 
458     if (fail) {
459         return -EINVAL;
460     }
461 
462     phys_bitmap_bytes = (uint64_t)entry->bitmap_table_size * s->cluster_size;
463     len = bdrv_getlength(bs);
464 
465     if (len < 0) {
466         return len;
467     }
468 
469     if (phys_bitmap_bytes > BME_MAX_PHYS_SIZE) {
470         return -EINVAL;
471     }
472 
473     if (!(entry->flags & BME_FLAG_IN_USE) &&
474         (len > ((phys_bitmap_bytes * 8) << entry->granularity_bits)))
475     {
476         /*
477          * We've loaded a valid bitmap (IN_USE not set) or we are going to
478          * store a valid bitmap, but the allocated bitmap table size is not
479          * enough to store this bitmap.
480          *
481          * Note, that it's OK to have an invalid bitmap with invalid size due
482          * to a bitmap that was not correctly saved after image resize.
483          */
484         return -EINVAL;
485     }
486 
487     return 0;
488 }
489 
bitmap_directory_to_be(uint8_t * dir,size_t size)490 static inline void bitmap_directory_to_be(uint8_t *dir, size_t size)
491 {
492     uint8_t *end = dir + size;
493     while (dir < end) {
494         Qcow2BitmapDirEntry *e = (Qcow2BitmapDirEntry *)dir;
495         dir += dir_entry_size(e);
496 
497         bitmap_dir_entry_to_be(e);
498     }
499 }
500 
501 /*
502  * Bitmap List public functions
503  */
504 
bitmap_free(Qcow2Bitmap * bm)505 static void bitmap_free(Qcow2Bitmap *bm)
506 {
507     if (bm == NULL) {
508         return;
509     }
510 
511     g_free(bm->name);
512     g_free(bm);
513 }
514 
bitmap_list_free(Qcow2BitmapList * bm_list)515 static void bitmap_list_free(Qcow2BitmapList *bm_list)
516 {
517     Qcow2Bitmap *bm;
518 
519     if (bm_list == NULL) {
520         return;
521     }
522 
523     while ((bm = QSIMPLEQ_FIRST(bm_list)) != NULL) {
524         QSIMPLEQ_REMOVE_HEAD(bm_list, entry);
525         bitmap_free(bm);
526     }
527 
528     g_free(bm_list);
529 }
530 
bitmap_list_new(void)531 static Qcow2BitmapList *bitmap_list_new(void)
532 {
533     Qcow2BitmapList *bm_list = g_new(Qcow2BitmapList, 1);
534     QSIMPLEQ_INIT(bm_list);
535 
536     return bm_list;
537 }
538 
bitmap_list_count(Qcow2BitmapList * bm_list)539 static uint32_t bitmap_list_count(Qcow2BitmapList *bm_list)
540 {
541     Qcow2Bitmap *bm;
542     uint32_t nb_bitmaps = 0;
543 
544     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
545         nb_bitmaps++;
546     }
547 
548     return nb_bitmaps;
549 }
550 
551 /* bitmap_list_load
552  * Get bitmap list from qcow2 image. Actually reads bitmap directory,
553  * checks it and convert to bitmap list.
554  */
555 static Qcow2BitmapList * GRAPH_RDLOCK
bitmap_list_load(BlockDriverState * bs,uint64_t offset,uint64_t size,Error ** errp)556 bitmap_list_load(BlockDriverState *bs, uint64_t offset, uint64_t size,
557                  Error **errp)
558 {
559     int ret;
560     BDRVQcow2State *s = bs->opaque;
561     uint8_t *dir, *dir_end;
562     Qcow2BitmapDirEntry *e;
563     uint32_t nb_dir_entries = 0;
564     Qcow2BitmapList *bm_list = NULL;
565 
566     if (size == 0) {
567         error_setg(errp, "Requested bitmap directory size is zero");
568         return NULL;
569     }
570 
571     if (size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
572         error_setg(errp, "Requested bitmap directory size is too big");
573         return NULL;
574     }
575 
576     dir = g_try_malloc(size);
577     if (dir == NULL) {
578         error_setg(errp, "Failed to allocate space for bitmap directory");
579         return NULL;
580     }
581     dir_end = dir + size;
582 
583     ret = bdrv_pread(bs->file, offset, size, dir, 0);
584     if (ret < 0) {
585         error_setg_errno(errp, -ret, "Failed to read bitmap directory");
586         goto fail;
587     }
588 
589     bm_list = bitmap_list_new();
590     for (e = (Qcow2BitmapDirEntry *)dir;
591          e < (Qcow2BitmapDirEntry *)dir_end;
592          e = next_dir_entry(e))
593     {
594         Qcow2Bitmap *bm;
595 
596         if ((uint8_t *)(e + 1) > dir_end) {
597             goto broken_dir;
598         }
599 
600         if (++nb_dir_entries > s->nb_bitmaps) {
601             error_setg(errp, "More bitmaps found than specified in header"
602                        " extension");
603             goto fail;
604         }
605         bitmap_dir_entry_to_cpu(e);
606 
607         if ((uint8_t *)next_dir_entry(e) > dir_end) {
608             goto broken_dir;
609         }
610 
611         if (e->extra_data_size != 0) {
612             error_setg(errp, "Bitmap extra data is not supported");
613             goto fail;
614         }
615 
616         ret = check_dir_entry(bs, e);
617         if (ret < 0) {
618             error_setg(errp, "Bitmap '%.*s' doesn't satisfy the constraints",
619                        e->name_size, dir_entry_name_field(e));
620             goto fail;
621         }
622 
623         bm = g_new0(Qcow2Bitmap, 1);
624         bm->table.offset = e->bitmap_table_offset;
625         bm->table.size = e->bitmap_table_size;
626         bm->flags = e->flags;
627         bm->granularity_bits = e->granularity_bits;
628         bm->name = dir_entry_copy_name(e);
629         QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry);
630     }
631 
632     if (nb_dir_entries != s->nb_bitmaps) {
633         error_setg(errp, "Less bitmaps found than specified in header"
634                          " extension");
635         goto fail;
636     }
637 
638     if ((uint8_t *)e != dir_end) {
639         goto broken_dir;
640     }
641 
642     g_free(dir);
643     return bm_list;
644 
645 broken_dir:
646     error_setg(errp, "Broken bitmap directory");
647 
648 fail:
649     g_free(dir);
650     bitmap_list_free(bm_list);
651 
652     return NULL;
653 }
654 
655 int coroutine_fn
qcow2_check_bitmaps_refcounts(BlockDriverState * bs,BdrvCheckResult * res,void ** refcount_table,int64_t * refcount_table_size)656 qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
657                               void **refcount_table,
658                               int64_t *refcount_table_size)
659 {
660     int ret;
661     BDRVQcow2State *s = bs->opaque;
662     Qcow2BitmapList *bm_list;
663     Qcow2Bitmap *bm;
664 
665     if (s->nb_bitmaps == 0) {
666         return 0;
667     }
668 
669     ret = qcow2_inc_refcounts_imrt(bs, res, refcount_table, refcount_table_size,
670                                    s->bitmap_directory_offset,
671                                    s->bitmap_directory_size);
672     if (ret < 0) {
673         return ret;
674     }
675 
676     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
677                                s->bitmap_directory_size, NULL);
678     if (bm_list == NULL) {
679         res->corruptions++;
680         return -EINVAL;
681     }
682 
683     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
684         uint64_t *bitmap_table = NULL;
685         int i;
686 
687         ret = qcow2_inc_refcounts_imrt(bs, res,
688                                        refcount_table, refcount_table_size,
689                                        bm->table.offset,
690                                        bm->table.size * BME_TABLE_ENTRY_SIZE);
691         if (ret < 0) {
692             goto out;
693         }
694 
695         ret = bitmap_table_load(bs, &bm->table, &bitmap_table);
696         if (ret < 0) {
697             res->corruptions++;
698             goto out;
699         }
700 
701         for (i = 0; i < bm->table.size; ++i) {
702             uint64_t entry = bitmap_table[i];
703             uint64_t offset = entry & BME_TABLE_ENTRY_OFFSET_MASK;
704 
705             if (check_table_entry(entry, s->cluster_size) < 0) {
706                 res->corruptions++;
707                 continue;
708             }
709 
710             if (offset == 0) {
711                 continue;
712             }
713 
714             ret = qcow2_inc_refcounts_imrt(bs, res,
715                                            refcount_table, refcount_table_size,
716                                            offset, s->cluster_size);
717             if (ret < 0) {
718                 g_free(bitmap_table);
719                 goto out;
720             }
721         }
722 
723         g_free(bitmap_table);
724     }
725 
726 out:
727     bitmap_list_free(bm_list);
728 
729     return ret;
730 }
731 
732 /* bitmap_list_store
733  * Store bitmap list to qcow2 image as a bitmap directory.
734  * Everything is checked.
735  */
736 static int GRAPH_RDLOCK
bitmap_list_store(BlockDriverState * bs,Qcow2BitmapList * bm_list,uint64_t * offset,uint64_t * size,bool in_place)737 bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list,
738                   uint64_t *offset, uint64_t *size, bool in_place)
739 {
740     int ret;
741     uint8_t *dir;
742     int64_t dir_offset = 0;
743     uint64_t dir_size = 0;
744     Qcow2Bitmap *bm;
745     Qcow2BitmapDirEntry *e;
746 
747     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
748         dir_size += calc_dir_entry_size(strlen(bm->name), 0);
749     }
750 
751     if (dir_size == 0 || dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
752         return -EINVAL;
753     }
754 
755     if (in_place) {
756         if (*size != dir_size || *offset == 0) {
757             return -EINVAL;
758         }
759 
760         dir_offset = *offset;
761     }
762 
763     dir = g_try_malloc0(dir_size);
764     if (dir == NULL) {
765         return -ENOMEM;
766     }
767 
768     e = (Qcow2BitmapDirEntry *)dir;
769     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
770         e->bitmap_table_offset = bm->table.offset;
771         e->bitmap_table_size = bm->table.size;
772         e->flags = bm->flags;
773         e->type = BT_DIRTY_TRACKING_BITMAP;
774         e->granularity_bits = bm->granularity_bits;
775         e->name_size = strlen(bm->name);
776         e->extra_data_size = 0;
777         memcpy(e + 1, bm->name, e->name_size);
778 
779         if (check_dir_entry(bs, e) < 0) {
780             ret = -EINVAL;
781             goto fail;
782         }
783 
784         e = next_dir_entry(e);
785     }
786 
787     bitmap_directory_to_be(dir, dir_size);
788 
789     if (!in_place) {
790         dir_offset = qcow2_alloc_clusters(bs, dir_size);
791         if (dir_offset < 0) {
792             ret = dir_offset;
793             goto fail;
794         }
795     }
796 
797     /* Actually, even in the in-place case ignoring QCOW2_OL_BITMAP_DIRECTORY
798      * is not necessary, because we drop QCOW2_AUTOCLEAR_BITMAPS when updating
799      * bitmap directory in-place (actually, turn-off the extension), which is
800      * checked in qcow2_check_metadata_overlap() */
801     ret = qcow2_pre_write_overlap_check(
802             bs, in_place ? QCOW2_OL_BITMAP_DIRECTORY : 0, dir_offset, dir_size,
803             false);
804     if (ret < 0) {
805         goto fail;
806     }
807 
808     ret = bdrv_pwrite(bs->file, dir_offset, dir_size, dir, 0);
809     if (ret < 0) {
810         goto fail;
811     }
812 
813     g_free(dir);
814 
815     if (!in_place) {
816         *size = dir_size;
817         *offset = dir_offset;
818     }
819 
820     return 0;
821 
822 fail:
823     g_free(dir);
824 
825     if (!in_place && dir_offset > 0) {
826         qcow2_free_clusters(bs, dir_offset, dir_size, QCOW2_DISCARD_OTHER);
827     }
828 
829     return ret;
830 }
831 
832 /*
833  * Bitmap List end
834  */
835 
836 static int GRAPH_RDLOCK
update_ext_header_and_dir_in_place(BlockDriverState * bs,Qcow2BitmapList * bm_list)837 update_ext_header_and_dir_in_place(BlockDriverState *bs,
838                                    Qcow2BitmapList *bm_list)
839 {
840     BDRVQcow2State *s = bs->opaque;
841     int ret;
842 
843     if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS) ||
844         bm_list == NULL || QSIMPLEQ_EMPTY(bm_list) ||
845         bitmap_list_count(bm_list) != s->nb_bitmaps)
846     {
847         return -EINVAL;
848     }
849 
850     s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
851     ret = update_header_sync(bs);
852     if (ret < 0) {
853         /* Two variants are possible here:
854          * 1. Autoclear flag is dropped, all bitmaps will be lost.
855          * 2. Autoclear flag is not dropped, old state is left.
856          */
857         return ret;
858     }
859 
860     /* autoclear bit is not set, so we can safely update bitmap directory */
861 
862     ret = bitmap_list_store(bs, bm_list, &s->bitmap_directory_offset,
863                             &s->bitmap_directory_size, true);
864     if (ret < 0) {
865         /* autoclear bit is cleared, so all leaked clusters would be removed on
866          * qemu-img check */
867         return ret;
868     }
869 
870     ret = update_header_sync(bs);
871     if (ret < 0) {
872         /* autoclear bit is cleared, so all leaked clusters would be removed on
873          * qemu-img check */
874         return ret;
875     }
876 
877     s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
878     return update_header_sync(bs);
879     /* If final update_header_sync() fails, two variants are possible:
880      * 1. Autoclear flag is not set, all bitmaps will be lost.
881      * 2. Autoclear flag is set, header and directory are successfully updated.
882      */
883 }
884 
885 static int GRAPH_RDLOCK
update_ext_header_and_dir(BlockDriverState * bs,Qcow2BitmapList * bm_list)886 update_ext_header_and_dir(BlockDriverState *bs, Qcow2BitmapList *bm_list)
887 {
888     BDRVQcow2State *s = bs->opaque;
889     int ret;
890     uint64_t new_offset = 0;
891     uint64_t new_size = 0;
892     uint32_t new_nb_bitmaps = 0;
893     uint64_t old_offset = s->bitmap_directory_offset;
894     uint64_t old_size = s->bitmap_directory_size;
895     uint32_t old_nb_bitmaps = s->nb_bitmaps;
896     uint64_t old_autocl = s->autoclear_features;
897 
898     if (bm_list != NULL && !QSIMPLEQ_EMPTY(bm_list)) {
899         new_nb_bitmaps = bitmap_list_count(bm_list);
900 
901         if (new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
902             return -EINVAL;
903         }
904 
905         ret = bitmap_list_store(bs, bm_list, &new_offset, &new_size, false);
906         if (ret < 0) {
907             return ret;
908         }
909 
910         ret = qcow2_flush_caches(bs);
911         if (ret < 0) {
912             goto fail;
913         }
914 
915         s->autoclear_features |= QCOW2_AUTOCLEAR_BITMAPS;
916     } else {
917         s->autoclear_features &= ~(uint64_t)QCOW2_AUTOCLEAR_BITMAPS;
918     }
919 
920     s->bitmap_directory_offset = new_offset;
921     s->bitmap_directory_size = new_size;
922     s->nb_bitmaps = new_nb_bitmaps;
923 
924     ret = update_header_sync(bs);
925     if (ret < 0) {
926         goto fail;
927     }
928 
929     if (old_size > 0) {
930         qcow2_free_clusters(bs, old_offset, old_size, QCOW2_DISCARD_OTHER);
931     }
932 
933     return 0;
934 
935 fail:
936     if (new_offset > 0) {
937         qcow2_free_clusters(bs, new_offset, new_size, QCOW2_DISCARD_OTHER);
938     }
939 
940     s->bitmap_directory_offset = old_offset;
941     s->bitmap_directory_size = old_size;
942     s->nb_bitmaps = old_nb_bitmaps;
943     s->autoclear_features = old_autocl;
944 
945     return ret;
946 }
947 
948 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
release_dirty_bitmap_helper(gpointer bitmap,gpointer bs)949 static void release_dirty_bitmap_helper(gpointer bitmap,
950                                         gpointer bs)
951 {
952     bdrv_release_dirty_bitmap(bitmap);
953 }
954 
955 /* for g_slist_foreach for GSList of BdrvDirtyBitmap* elements */
set_readonly_helper(gpointer bitmap,gpointer value)956 static void set_readonly_helper(gpointer bitmap, gpointer value)
957 {
958     bdrv_dirty_bitmap_set_readonly(bitmap, (bool)value);
959 }
960 
961 /*
962  * Return true on success, false on failure.
963  * If header_updated is not NULL then it is set appropriately regardless of
964  * the return value.
965  */
966 bool coroutine_fn
qcow2_load_dirty_bitmaps(BlockDriverState * bs,bool * header_updated,Error ** errp)967 qcow2_load_dirty_bitmaps(BlockDriverState *bs,
968                          bool *header_updated, Error **errp)
969 {
970     BDRVQcow2State *s = bs->opaque;
971     Qcow2BitmapList *bm_list;
972     Qcow2Bitmap *bm;
973     GSList *created_dirty_bitmaps = NULL;
974     bool needs_update = false;
975 
976     if (header_updated) {
977         *header_updated = false;
978     }
979 
980     if (s->nb_bitmaps == 0) {
981         /* No bitmaps - nothing to do */
982         return true;
983     }
984 
985     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
986                                s->bitmap_directory_size, errp);
987     if (bm_list == NULL) {
988         return false;
989     }
990 
991     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
992         BdrvDirtyBitmap *bitmap;
993 
994         if ((bm->flags & BME_FLAG_IN_USE) &&
995             bdrv_find_dirty_bitmap(bs, bm->name))
996         {
997             /*
998              * We already have corresponding BdrvDirtyBitmap, and bitmap in the
999              * image is marked IN_USE. Firstly, this state is valid, no reason
1000              * to consider existing BdrvDirtyBitmap to be bad. Secondly it's
1001              * absolutely possible, when we do migration with shared storage
1002              * with dirty-bitmaps capability enabled: if the bitmap was loaded
1003              * from this storage before migration start, the storage will
1004              * of-course contain IN_USE outdated version of the bitmap, and we
1005              * should not load it on migration target, as we already have this
1006              * bitmap, being migrated.
1007              */
1008             continue;
1009         }
1010 
1011         bitmap = load_bitmap(bs, bm, errp);
1012         if (bitmap == NULL) {
1013             goto fail;
1014         }
1015 
1016         bdrv_dirty_bitmap_set_persistence(bitmap, true);
1017         if (bm->flags & BME_FLAG_IN_USE) {
1018             bdrv_dirty_bitmap_set_inconsistent(bitmap);
1019         } else {
1020             /* NB: updated flags only get written if can_write(bs) is true. */
1021             bm->flags |= BME_FLAG_IN_USE;
1022             needs_update = true;
1023         }
1024         if (!(bm->flags & BME_FLAG_AUTO)) {
1025             bdrv_disable_dirty_bitmap(bitmap);
1026         }
1027         created_dirty_bitmaps =
1028             g_slist_append(created_dirty_bitmaps, bitmap);
1029     }
1030 
1031     if (needs_update && can_write(bs)) {
1032         /* in_use flags must be updated */
1033         int ret = update_ext_header_and_dir_in_place(bs, bm_list);
1034         if (ret < 0) {
1035             error_setg_errno(errp, -ret, "Can't update bitmap directory");
1036             goto fail;
1037         }
1038         if (header_updated) {
1039             *header_updated = true;
1040         }
1041     }
1042 
1043     if (!can_write(bs)) {
1044         g_slist_foreach(created_dirty_bitmaps, set_readonly_helper,
1045                         (gpointer)true);
1046     }
1047 
1048     g_slist_free(created_dirty_bitmaps);
1049     bitmap_list_free(bm_list);
1050 
1051     return true;
1052 
1053 fail:
1054     g_slist_foreach(created_dirty_bitmaps, release_dirty_bitmap_helper, bs);
1055     g_slist_free(created_dirty_bitmaps);
1056     bitmap_list_free(bm_list);
1057 
1058     return false;
1059 }
1060 
1061 
get_bitmap_info_flags(uint32_t flags)1062 static Qcow2BitmapInfoFlagsList *get_bitmap_info_flags(uint32_t flags)
1063 {
1064     Qcow2BitmapInfoFlagsList *list = NULL;
1065     Qcow2BitmapInfoFlagsList **tail = &list;
1066     int i;
1067 
1068     static const struct {
1069         int bme;  /* Bitmap directory entry flags */
1070         int info; /* The flags to report to the user */
1071     } map[] = {
1072         { BME_FLAG_IN_USE, QCOW2_BITMAP_INFO_FLAGS_IN_USE },
1073         { BME_FLAG_AUTO,   QCOW2_BITMAP_INFO_FLAGS_AUTO },
1074     };
1075 
1076     int map_size = ARRAY_SIZE(map);
1077 
1078     for (i = 0; i < map_size; ++i) {
1079         if (flags & map[i].bme) {
1080             QAPI_LIST_APPEND(tail, map[i].info);
1081             flags &= ~map[i].bme;
1082         }
1083     }
1084     /* Check if the BME_* mapping above is complete */
1085     assert(!flags);
1086 
1087     return list;
1088 }
1089 
1090 /*
1091  * qcow2_get_bitmap_info_list()
1092  * Returns a list of QCOW2 bitmap details.
1093  * On success return true with info_list set (note, that if there are no
1094  * bitmaps, info_list is set to NULL).
1095  * On failure return false with errp set.
1096  */
qcow2_get_bitmap_info_list(BlockDriverState * bs,Qcow2BitmapInfoList ** info_list,Error ** errp)1097 bool qcow2_get_bitmap_info_list(BlockDriverState *bs,
1098                                 Qcow2BitmapInfoList **info_list, Error **errp)
1099 {
1100     BDRVQcow2State *s = bs->opaque;
1101     Qcow2BitmapList *bm_list;
1102     Qcow2Bitmap *bm;
1103     Qcow2BitmapInfoList **tail;
1104 
1105     if (s->nb_bitmaps == 0) {
1106         *info_list = NULL;
1107         return true;
1108     }
1109 
1110     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1111                                s->bitmap_directory_size, errp);
1112     if (!bm_list) {
1113         return false;
1114     }
1115 
1116     *info_list = NULL;
1117     tail = info_list;
1118 
1119     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1120         Qcow2BitmapInfo *info = g_new0(Qcow2BitmapInfo, 1);
1121         info->granularity = 1U << bm->granularity_bits;
1122         info->name = g_strdup(bm->name);
1123         info->flags = get_bitmap_info_flags(bm->flags & ~BME_RESERVED_FLAGS);
1124         QAPI_LIST_APPEND(tail, info);
1125     }
1126 
1127     bitmap_list_free(bm_list);
1128 
1129     return true;
1130 }
1131 
qcow2_reopen_bitmaps_rw(BlockDriverState * bs,Error ** errp)1132 int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp)
1133 {
1134     BDRVQcow2State *s = bs->opaque;
1135     Qcow2BitmapList *bm_list;
1136     Qcow2Bitmap *bm;
1137     GSList *ro_dirty_bitmaps = NULL;
1138     int ret = -EINVAL;
1139     bool need_header_update = false;
1140 
1141     if (s->nb_bitmaps == 0) {
1142         /* No bitmaps - nothing to do */
1143         return 0;
1144     }
1145 
1146     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1147                                s->bitmap_directory_size, errp);
1148     if (bm_list == NULL) {
1149         return -EINVAL;
1150     }
1151 
1152     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1153         BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name);
1154 
1155         if (!bitmap) {
1156             error_setg(errp, "Unexpected bitmap '%s' in image '%s'",
1157                        bm->name, bs->filename);
1158             goto out;
1159         }
1160 
1161         if (!(bm->flags & BME_FLAG_IN_USE)) {
1162             if (!bdrv_dirty_bitmap_readonly(bitmap)) {
1163                 error_setg(errp, "Corruption: bitmap '%s' is not marked IN_USE "
1164                            "in the image '%s' and not marked readonly in RAM",
1165                            bm->name, bs->filename);
1166                 goto out;
1167             }
1168             if (bdrv_dirty_bitmap_inconsistent(bitmap)) {
1169                 error_setg(errp, "Corruption: bitmap '%s' is inconsistent but "
1170                            "is not marked IN_USE in the image '%s'", bm->name,
1171                            bs->filename);
1172                 goto out;
1173             }
1174 
1175             bm->flags |= BME_FLAG_IN_USE;
1176             need_header_update = true;
1177         } else {
1178             /*
1179              * What if flags already has BME_FLAG_IN_USE ?
1180              *
1181              * 1. if we are reopening RW -> RW it's OK, of course.
1182              * 2. if we are reopening RO -> RW:
1183              *   2.1 if @bitmap is inconsistent, it's OK. It means that it was
1184              *       inconsistent (IN_USE) when we loaded it
1185              *   2.2 if @bitmap is not inconsistent. This seems to be impossible
1186              *       and implies third party interaction. Let's error-out for
1187              *       safety.
1188              */
1189             if (bdrv_dirty_bitmap_readonly(bitmap) &&
1190                 !bdrv_dirty_bitmap_inconsistent(bitmap))
1191             {
1192                 error_setg(errp, "Corruption: bitmap '%s' is marked IN_USE "
1193                            "in the image '%s' but it is readonly and "
1194                            "consistent in RAM",
1195                            bm->name, bs->filename);
1196                 goto out;
1197             }
1198         }
1199 
1200         if (bdrv_dirty_bitmap_readonly(bitmap)) {
1201             ro_dirty_bitmaps = g_slist_append(ro_dirty_bitmaps, bitmap);
1202         }
1203     }
1204 
1205     if (need_header_update) {
1206         if (!can_write(bs->file->bs) || !(bs->file->perm & BLK_PERM_WRITE)) {
1207             error_setg(errp, "Failed to reopen bitmaps rw: no write access "
1208                        "the protocol file");
1209             goto out;
1210         }
1211 
1212         /* in_use flags must be updated */
1213         ret = update_ext_header_and_dir_in_place(bs, bm_list);
1214         if (ret < 0) {
1215             error_setg_errno(errp, -ret, "Cannot update bitmap directory");
1216             goto out;
1217         }
1218     }
1219 
1220     g_slist_foreach(ro_dirty_bitmaps, set_readonly_helper, (gpointer)false);
1221     ret = 0;
1222 
1223 out:
1224     g_slist_free(ro_dirty_bitmaps);
1225     bitmap_list_free(bm_list);
1226 
1227     return ret;
1228 }
1229 
1230 /* Checks to see if it's safe to resize bitmaps */
qcow2_truncate_bitmaps_check(BlockDriverState * bs,Error ** errp)1231 int coroutine_fn qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp)
1232 {
1233     BDRVQcow2State *s = bs->opaque;
1234     Qcow2BitmapList *bm_list;
1235     Qcow2Bitmap *bm;
1236     int ret = 0;
1237 
1238     if (s->nb_bitmaps == 0) {
1239         return 0;
1240     }
1241 
1242     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1243                                s->bitmap_directory_size, errp);
1244     if (bm_list == NULL) {
1245         return -EINVAL;
1246     }
1247 
1248     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1249         BdrvDirtyBitmap *bitmap = bdrv_find_dirty_bitmap(bs, bm->name);
1250         if (bitmap == NULL) {
1251             /*
1252              * We rely on all bitmaps being in-memory to be able to resize them,
1253              * Otherwise, we'd need to resize them on disk explicitly
1254              */
1255             error_setg(errp, "Cannot resize qcow2 with persistent bitmaps that "
1256                        "were not loaded into memory");
1257             ret = -ENOTSUP;
1258             goto out;
1259         }
1260 
1261         /*
1262          * The checks against readonly and busy are redundant, but certainly
1263          * do no harm. checks against inconsistent are crucial:
1264          */
1265         if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
1266             ret = -ENOTSUP;
1267             goto out;
1268         }
1269     }
1270 
1271 out:
1272     bitmap_list_free(bm_list);
1273     return ret;
1274 }
1275 
1276 /* store_bitmap_data()
1277  * Store bitmap to image, filling bitmap table accordingly.
1278  */
1279 static uint64_t * GRAPH_RDLOCK
store_bitmap_data(BlockDriverState * bs,BdrvDirtyBitmap * bitmap,uint32_t * bitmap_table_size,Error ** errp)1280 store_bitmap_data(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,
1281                   uint32_t *bitmap_table_size, Error **errp)
1282 {
1283     int ret;
1284     BDRVQcow2State *s = bs->opaque;
1285     int64_t offset;
1286     uint64_t limit;
1287     uint64_t bm_size = bdrv_dirty_bitmap_size(bitmap);
1288     const char *bm_name = bdrv_dirty_bitmap_name(bitmap);
1289     uint8_t *buf = NULL;
1290     uint64_t *tb;
1291     uint64_t tb_size =
1292             size_to_clusters(s,
1293                 bdrv_dirty_bitmap_serialization_size(bitmap, 0, bm_size));
1294 
1295     if (tb_size > BME_MAX_TABLE_SIZE ||
1296         tb_size * s->cluster_size > BME_MAX_PHYS_SIZE)
1297     {
1298         error_setg(errp, "Bitmap '%s' is too big", bm_name);
1299         return NULL;
1300     }
1301 
1302     tb = g_try_new0(uint64_t, tb_size);
1303     if (tb == NULL) {
1304         error_setg(errp, "No memory");
1305         return NULL;
1306     }
1307 
1308     buf = g_malloc(s->cluster_size);
1309     limit = bdrv_dirty_bitmap_serialization_coverage(s->cluster_size, bitmap);
1310     assert(DIV_ROUND_UP(bm_size, limit) == tb_size);
1311 
1312     offset = 0;
1313     while ((offset = bdrv_dirty_bitmap_next_dirty(bitmap, offset, INT64_MAX))
1314            >= 0)
1315     {
1316         uint64_t cluster = offset / limit;
1317         uint64_t end, write_size;
1318         int64_t off;
1319 
1320         /*
1321          * We found the first dirty offset, but want to write out the
1322          * entire cluster of the bitmap that includes that offset,
1323          * including any leading zero bits.
1324          */
1325         offset = QEMU_ALIGN_DOWN(offset, limit);
1326         end = MIN(bm_size, offset + limit);
1327         write_size = bdrv_dirty_bitmap_serialization_size(bitmap, offset,
1328                                                           end - offset);
1329         assert(write_size <= s->cluster_size);
1330 
1331         off = qcow2_alloc_clusters(bs, s->cluster_size);
1332         if (off < 0) {
1333             error_setg_errno(errp, -off,
1334                              "Failed to allocate clusters for bitmap '%s'",
1335                              bm_name);
1336             goto fail;
1337         }
1338         tb[cluster] = off;
1339 
1340         bdrv_dirty_bitmap_serialize_part(bitmap, buf, offset, end - offset);
1341         if (write_size < s->cluster_size) {
1342             memset(buf + write_size, 0, s->cluster_size - write_size);
1343         }
1344 
1345         ret = qcow2_pre_write_overlap_check(bs, 0, off, s->cluster_size, false);
1346         if (ret < 0) {
1347             error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1348             goto fail;
1349         }
1350 
1351         ret = bdrv_pwrite(bs->file, off, s->cluster_size, buf, 0);
1352         if (ret < 0) {
1353             error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1354                              bm_name);
1355             goto fail;
1356         }
1357 
1358         offset = end;
1359     }
1360 
1361     *bitmap_table_size = tb_size;
1362     g_free(buf);
1363 
1364     return tb;
1365 
1366 fail:
1367     clear_bitmap_table(bs, tb, tb_size);
1368     g_free(buf);
1369     g_free(tb);
1370 
1371     return NULL;
1372 }
1373 
1374 /* store_bitmap()
1375  * Store bm->dirty_bitmap to qcow2.
1376  * Set bm->table_offset and bm->table_size accordingly.
1377  */
1378 static int GRAPH_RDLOCK
store_bitmap(BlockDriverState * bs,Qcow2Bitmap * bm,Error ** errp)1379 store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
1380 {
1381     int ret;
1382     uint64_t *tb;
1383     int64_t tb_offset;
1384     uint32_t tb_size;
1385     BdrvDirtyBitmap *bitmap = bm->dirty_bitmap;
1386     const char *bm_name;
1387 
1388     assert(bitmap != NULL);
1389 
1390     bm_name = bdrv_dirty_bitmap_name(bitmap);
1391 
1392     tb = store_bitmap_data(bs, bitmap, &tb_size, errp);
1393     if (tb == NULL) {
1394         return -EINVAL;
1395     }
1396 
1397     assert(tb_size <= BME_MAX_TABLE_SIZE);
1398     tb_offset = qcow2_alloc_clusters(bs, tb_size * sizeof(tb[0]));
1399     if (tb_offset < 0) {
1400         error_setg_errno(errp, -tb_offset,
1401                          "Failed to allocate clusters for bitmap '%s'",
1402                          bm_name);
1403         ret = tb_offset;
1404         goto fail;
1405     }
1406 
1407     ret = qcow2_pre_write_overlap_check(bs, 0, tb_offset,
1408                                         tb_size * sizeof(tb[0]), false);
1409     if (ret < 0) {
1410         error_setg_errno(errp, -ret, "Qcow2 overlap check failed");
1411         goto fail;
1412     }
1413 
1414     bitmap_table_bswap_be(tb, tb_size);
1415     ret = bdrv_pwrite(bs->file, tb_offset, tb_size * sizeof(tb[0]), tb, 0);
1416     if (ret < 0) {
1417         bitmap_table_bswap_be(tb, tb_size);
1418         error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
1419                          bm_name);
1420         goto fail;
1421     }
1422 
1423     g_free(tb);
1424 
1425     bm->table.offset = tb_offset;
1426     bm->table.size = tb_size;
1427 
1428     return 0;
1429 
1430 fail:
1431     clear_bitmap_table(bs, tb, tb_size);
1432 
1433     if (tb_offset > 0) {
1434         qcow2_free_clusters(bs, tb_offset, tb_size * sizeof(tb[0]),
1435                             QCOW2_DISCARD_OTHER);
1436     }
1437 
1438     g_free(tb);
1439 
1440     return ret;
1441 }
1442 
find_bitmap_by_name(Qcow2BitmapList * bm_list,const char * name)1443 static Qcow2Bitmap *find_bitmap_by_name(Qcow2BitmapList *bm_list,
1444                                         const char *name)
1445 {
1446     Qcow2Bitmap *bm;
1447 
1448     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1449         if (strcmp(name, bm->name) == 0) {
1450             return bm;
1451         }
1452     }
1453 
1454     return NULL;
1455 }
1456 
qcow2_co_remove_persistent_dirty_bitmap(BlockDriverState * bs,const char * name,Error ** errp)1457 int coroutine_fn qcow2_co_remove_persistent_dirty_bitmap(BlockDriverState *bs,
1458                                                          const char *name,
1459                                                          Error **errp)
1460 {
1461     int ret;
1462     BDRVQcow2State *s = bs->opaque;
1463     Qcow2Bitmap *bm = NULL;
1464     Qcow2BitmapList *bm_list;
1465 
1466     if (s->nb_bitmaps == 0) {
1467         /*
1468          * Absence of the bitmap is not an error: see explanation above
1469          * bdrv_co_remove_persistent_dirty_bitmap() definition.
1470          */
1471         return 0;
1472     }
1473 
1474     qemu_co_mutex_lock(&s->lock);
1475 
1476     bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1477                                s->bitmap_directory_size, errp);
1478     if (bm_list == NULL) {
1479         ret = -EIO;
1480         goto out;
1481     }
1482 
1483     bm = find_bitmap_by_name(bm_list, name);
1484     if (bm == NULL) {
1485         /* Absence of the bitmap is not an error, see above. */
1486         ret = 0;
1487         goto out;
1488     }
1489 
1490     QSIMPLEQ_REMOVE(bm_list, bm, Qcow2Bitmap, entry);
1491 
1492     ret = update_ext_header_and_dir(bs, bm_list);
1493     if (ret < 0) {
1494         error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1495         goto out;
1496     }
1497 
1498     free_bitmap_clusters(bs, &bm->table);
1499 
1500 out:
1501     qemu_co_mutex_unlock(&s->lock);
1502 
1503     bitmap_free(bm);
1504     bitmap_list_free(bm_list);
1505 
1506     return ret;
1507 }
1508 
1509 /*
1510  * qcow2_store_persistent_dirty_bitmaps
1511  *
1512  * Stores persistent BdrvDirtyBitmap objects.
1513  *
1514  * @release_stored: if true, release BdrvDirtyBitmap's after storing to the
1515  * image. This is used in two cases, both via qcow2_inactivate:
1516  * 1. bdrv_close: It's correct to remove bitmaps on close.
1517  * 2. migration: If bitmaps are migrated through migration channel via
1518  *    'dirty-bitmaps' migration capability they are not handled by this code.
1519  *    Otherwise, it's OK to drop BdrvDirtyBitmap's and reload them on
1520  *    invalidation.
1521  *
1522  * Anyway, it's correct to remove BdrvDirtyBitmap's on inactivation, as
1523  * inactivation means that we lose control on disk, and therefore on bitmaps,
1524  * we should sync them and do not touch more.
1525  *
1526  * Contrariwise, we don't want to release any bitmaps on just reopen-to-ro,
1527  * when we need to store them, as image is still under our control, and it's
1528  * good to keep all the bitmaps in read-only mode. Moreover, keeping them
1529  * read-only is correct because this is what would happen if we opened the node
1530  * readonly to begin with, and whether we opened directly or reopened to that
1531  * state shouldn't matter for the state we get afterward.
1532  */
qcow2_store_persistent_dirty_bitmaps(BlockDriverState * bs,bool release_stored,Error ** errp)1533 bool qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs,
1534                                           bool release_stored, Error **errp)
1535 {
1536     ERRP_GUARD();
1537     BdrvDirtyBitmap *bitmap;
1538     BDRVQcow2State *s = bs->opaque;
1539     uint32_t new_nb_bitmaps = s->nb_bitmaps;
1540     uint64_t new_dir_size = s->bitmap_directory_size;
1541     int ret;
1542     Qcow2BitmapList *bm_list;
1543     Qcow2Bitmap *bm;
1544     QSIMPLEQ_HEAD(, Qcow2BitmapTable) drop_tables;
1545     Qcow2BitmapTable *tb, *tb_next;
1546     bool need_write = false;
1547 
1548     QSIMPLEQ_INIT(&drop_tables);
1549 
1550     if (s->nb_bitmaps == 0) {
1551         bm_list = bitmap_list_new();
1552     } else {
1553         bm_list = bitmap_list_load(bs, s->bitmap_directory_offset,
1554                                    s->bitmap_directory_size, errp);
1555         if (bm_list == NULL) {
1556             return false;
1557         }
1558     }
1559 
1560     /* check constraints and names */
1561     FOR_EACH_DIRTY_BITMAP(bs, bitmap) {
1562         const char *name = bdrv_dirty_bitmap_name(bitmap);
1563         uint32_t granularity = bdrv_dirty_bitmap_granularity(bitmap);
1564 
1565         if (!bdrv_dirty_bitmap_get_persistence(bitmap) ||
1566             bdrv_dirty_bitmap_inconsistent(bitmap)) {
1567             continue;
1568         }
1569 
1570         if (bdrv_dirty_bitmap_readonly(bitmap)) {
1571             /*
1572              * Store the bitmap in the associated Qcow2Bitmap so it
1573              * can be released later
1574              */
1575             bm = find_bitmap_by_name(bm_list, name);
1576             if (bm) {
1577                 bm->dirty_bitmap = bitmap;
1578             }
1579             continue;
1580         }
1581 
1582         need_write = true;
1583 
1584         if (check_constraints_on_bitmap(bs, name, granularity, errp) < 0) {
1585             error_prepend(errp, "Bitmap '%s' doesn't satisfy the constraints: ",
1586                           name);
1587             goto fail;
1588         }
1589 
1590         bm = find_bitmap_by_name(bm_list, name);
1591         if (bm == NULL) {
1592             if (++new_nb_bitmaps > QCOW2_MAX_BITMAPS) {
1593                 error_setg(errp, "Too many persistent bitmaps");
1594                 goto fail;
1595             }
1596 
1597             new_dir_size += calc_dir_entry_size(strlen(name), 0);
1598             if (new_dir_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
1599                 error_setg(errp, "Bitmap directory is too large");
1600                 goto fail;
1601             }
1602 
1603             bm = g_new0(Qcow2Bitmap, 1);
1604             bm->name = g_strdup(name);
1605             QSIMPLEQ_INSERT_TAIL(bm_list, bm, entry);
1606         } else {
1607             if (!(bm->flags & BME_FLAG_IN_USE)) {
1608                 error_setg(errp, "Bitmap '%s' already exists in the image",
1609                            name);
1610                 goto fail;
1611             }
1612             tb = g_memdup2(&bm->table, sizeof(bm->table));
1613             bm->table.offset = 0;
1614             bm->table.size = 0;
1615             QSIMPLEQ_INSERT_TAIL(&drop_tables, tb, entry);
1616         }
1617         bm->flags = bdrv_dirty_bitmap_enabled(bitmap) ? BME_FLAG_AUTO : 0;
1618         bm->granularity_bits = ctz32(bdrv_dirty_bitmap_granularity(bitmap));
1619         bm->dirty_bitmap = bitmap;
1620     }
1621 
1622     if (!need_write) {
1623         goto success;
1624     }
1625 
1626     if (!can_write(bs)) {
1627         error_setg(errp, "No write access");
1628         goto fail;
1629     }
1630 
1631     /* allocate clusters and store bitmaps */
1632     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1633         bitmap = bm->dirty_bitmap;
1634 
1635         if (bitmap == NULL || bdrv_dirty_bitmap_readonly(bitmap)) {
1636             continue;
1637         }
1638 
1639         ret = store_bitmap(bs, bm, errp);
1640         if (ret < 0) {
1641             goto fail;
1642         }
1643     }
1644 
1645     ret = update_ext_header_and_dir(bs, bm_list);
1646     if (ret < 0) {
1647         error_setg_errno(errp, -ret, "Failed to update bitmap extension");
1648         goto fail;
1649     }
1650 
1651     /* Bitmap directory was successfully updated, so, old data can be dropped.
1652      * TODO it is better to reuse these clusters */
1653     QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1654         free_bitmap_clusters(bs, tb);
1655         g_free(tb);
1656     }
1657 
1658 success:
1659     if (release_stored) {
1660         QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1661             if (bm->dirty_bitmap == NULL) {
1662                 continue;
1663             }
1664 
1665             bdrv_release_dirty_bitmap(bm->dirty_bitmap);
1666         }
1667     }
1668 
1669     bitmap_list_free(bm_list);
1670     return true;
1671 
1672 fail:
1673     QSIMPLEQ_FOREACH(bm, bm_list, entry) {
1674         if (bm->dirty_bitmap == NULL || bm->table.offset == 0 ||
1675             bdrv_dirty_bitmap_readonly(bm->dirty_bitmap))
1676         {
1677             continue;
1678         }
1679 
1680         free_bitmap_clusters(bs, &bm->table);
1681     }
1682 
1683     QSIMPLEQ_FOREACH_SAFE(tb, &drop_tables, entry, tb_next) {
1684         g_free(tb);
1685     }
1686 
1687     bitmap_list_free(bm_list);
1688     return false;
1689 }
1690 
qcow2_reopen_bitmaps_ro(BlockDriverState * bs,Error ** errp)1691 int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp)
1692 {
1693     BdrvDirtyBitmap *bitmap;
1694 
1695     if (!qcow2_store_persistent_dirty_bitmaps(bs, false, errp)) {
1696         return -EINVAL;
1697     }
1698 
1699     FOR_EACH_DIRTY_BITMAP(bs, bitmap) {
1700         if (bdrv_dirty_bitmap_get_persistence(bitmap)) {
1701             bdrv_dirty_bitmap_set_readonly(bitmap, true);
1702         }
1703     }
1704 
1705     return 0;
1706 }
1707 
qcow2_co_can_store_new_dirty_bitmap(BlockDriverState * bs,const char * name,uint32_t granularity,Error ** errp)1708 bool coroutine_fn qcow2_co_can_store_new_dirty_bitmap(BlockDriverState *bs,
1709                                                       const char *name,
1710                                                       uint32_t granularity,
1711                                                       Error **errp)
1712 {
1713     ERRP_GUARD();
1714     BDRVQcow2State *s = bs->opaque;
1715     BdrvDirtyBitmap *bitmap;
1716     uint64_t bitmap_directory_size = 0;
1717     uint32_t nb_bitmaps = 0;
1718 
1719     if (bdrv_find_dirty_bitmap(bs, name)) {
1720         error_setg(errp, "Bitmap already exists: %s", name);
1721         return false;
1722     }
1723 
1724     if (s->qcow_version < 3) {
1725         /* Without autoclear_features, we would always have to assume
1726          * that a program without persistent dirty bitmap support has
1727          * accessed this qcow2 file when opening it, and would thus
1728          * have to drop all dirty bitmaps (defeating their purpose).
1729          */
1730         error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files");
1731         goto fail;
1732     }
1733 
1734     if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) {
1735         goto fail;
1736     }
1737 
1738     FOR_EACH_DIRTY_BITMAP(bs, bitmap) {
1739         if (bdrv_dirty_bitmap_get_persistence(bitmap)) {
1740             nb_bitmaps++;
1741             bitmap_directory_size +=
1742                 calc_dir_entry_size(strlen(bdrv_dirty_bitmap_name(bitmap)), 0);
1743         }
1744     }
1745     nb_bitmaps++;
1746     bitmap_directory_size += calc_dir_entry_size(strlen(name), 0);
1747 
1748     if (nb_bitmaps > QCOW2_MAX_BITMAPS) {
1749         error_setg(errp,
1750                    "Maximum number of persistent bitmaps is already reached");
1751         goto fail;
1752     }
1753 
1754     if (bitmap_directory_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) {
1755         error_setg(errp, "Not enough space in the bitmap directory");
1756         goto fail;
1757     }
1758 
1759     return true;
1760 
1761 fail:
1762     error_prepend(errp, "Can't make bitmap '%s' persistent in '%s': ",
1763                   name, bdrv_get_device_or_node_name(bs));
1764     return false;
1765 }
1766 
qcow2_supports_persistent_dirty_bitmap(BlockDriverState * bs)1767 bool qcow2_supports_persistent_dirty_bitmap(BlockDriverState *bs)
1768 {
1769     BDRVQcow2State *s = bs->opaque;
1770 
1771     return s->qcow_version >= 3;
1772 }
1773 
1774 /*
1775  * Compute the space required to copy bitmaps from @in_bs.
1776  *
1777  * The computation is based as if copying to a new image with the
1778  * given @cluster_size, which may differ from the cluster size in
1779  * @in_bs; in fact, @in_bs might be something other than qcow2.
1780  */
qcow2_get_persistent_dirty_bitmap_size(BlockDriverState * in_bs,uint32_t cluster_size)1781 uint64_t qcow2_get_persistent_dirty_bitmap_size(BlockDriverState *in_bs,
1782                                                 uint32_t cluster_size)
1783 {
1784     uint64_t bitmaps_size = 0;
1785     BdrvDirtyBitmap *bm;
1786     size_t bitmap_dir_size = 0;
1787 
1788     FOR_EACH_DIRTY_BITMAP(in_bs, bm) {
1789         if (bdrv_dirty_bitmap_get_persistence(bm)) {
1790             const char *name = bdrv_dirty_bitmap_name(bm);
1791             uint32_t granularity = bdrv_dirty_bitmap_granularity(bm);
1792             uint64_t bmbytes =
1793                 get_bitmap_bytes_needed(bdrv_dirty_bitmap_size(bm),
1794                                         granularity);
1795             uint64_t bmclusters = DIV_ROUND_UP(bmbytes, cluster_size);
1796 
1797             /* Assume the entire bitmap is allocated */
1798             bitmaps_size += bmclusters * cluster_size;
1799             /* Also reserve space for the bitmap table entries */
1800             bitmaps_size += ROUND_UP(bmclusters * BME_TABLE_ENTRY_SIZE,
1801                                      cluster_size);
1802             /* And space for contribution to bitmap directory size */
1803             bitmap_dir_size += calc_dir_entry_size(strlen(name), 0);
1804         }
1805     }
1806     bitmaps_size += ROUND_UP(bitmap_dir_size, cluster_size);
1807 
1808     return bitmaps_size;
1809 }
1810