1 /*
2  * Block dirty bitmap postcopy migration
3  *
4  * Copyright IBM, Corp. 2009
5  * Copyright (c) 2016-2017 Virtuozzo International GmbH. All rights reserved.
6  *
7  * Authors:
8  *  Liran Schour   <lirans@il.ibm.com>
9  *  Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
10  *
11  * This work is licensed under the terms of the GNU GPL, version 2.  See
12  * the COPYING file in the top-level directory.
13  * This file is derived from migration/block.c, so it's author and IBM copyright
14  * are here, although content is quite different.
15  *
16  * Contributions after 2012-01-13 are licensed under the terms of the
17  * GNU GPL, version 2 or (at your option) any later version.
18  *
19  *                                ***
20  *
21  * Here postcopy migration of dirty bitmaps is realized. Only QMP-addressable
22  * bitmaps are migrated.
23  *
24  * Bitmap migration implies creating bitmap with the same name and granularity
25  * in destination QEMU. If the bitmap with the same name (for the same node)
26  * already exists on destination an error will be generated.
27  *
28  * format of migration:
29  *
30  * # Header (shared for different chunk types)
31  * 1, 2 or 4 bytes: flags (see qemu_{put,put}_flags)
32  * [ 1 byte: node name size ] \  flags & DEVICE_NAME
33  * [ n bytes: node name     ] /
34  * [ 1 byte: bitmap name size ] \  flags & BITMAP_NAME
35  * [ n bytes: bitmap name     ] /
36  *
37  * # Start of bitmap migration (flags & START)
38  * header
39  * be64: granularity
40  * 1 byte: bitmap flags (corresponds to BdrvDirtyBitmap)
41  *   bit 0    -  bitmap is enabled
42  *   bit 1    -  bitmap is persistent
43  *   bit 2    -  bitmap is autoloading
44  *   bits 3-7 - reserved, must be zero
45  *
46  * # Complete of bitmap migration (flags & COMPLETE)
47  * header
48  *
49  * # Data chunk of bitmap migration
50  * header
51  * be64: start sector
52  * be32: number of sectors
53  * [ be64: buffer size  ] \ ! (flags & ZEROES)
54  * [ n bytes: buffer    ] /
55  *
56  * The last chunk in stream should contain flags & EOS. The chunk may skip
57  * device and/or bitmap names, assuming them to be the same with the previous
58  * chunk.
59  */
60 
61 #include "qemu/osdep.h"
62 #include "block/block.h"
63 #include "block/block_int.h"
64 #include "sysemu/block-backend.h"
65 #include "qemu/main-loop.h"
66 #include "qemu/error-report.h"
67 #include "migration/misc.h"
68 #include "migration/migration.h"
69 #include "qemu-file.h"
70 #include "migration/vmstate.h"
71 #include "migration/register.h"
72 #include "qemu/hbitmap.h"
73 #include "sysemu/sysemu.h"
74 #include "qemu/cutils.h"
75 #include "qapi/error.h"
76 #include "trace.h"
77 
78 #define CHUNK_SIZE     (1 << 10)
79 
80 /* Flags occupy one, two or four bytes (Big Endian). The size is determined as
81  * follows:
82  * in first (most significant) byte bit 8 is clear  -->  one byte
83  * in first byte bit 8 is set    -->  two or four bytes, depending on second
84  *                                    byte:
85  *    | in second byte bit 8 is clear  -->  two bytes
86  *    | in second byte bit 8 is set    -->  four bytes
87  */
88 #define DIRTY_BITMAP_MIG_FLAG_EOS           0x01
89 #define DIRTY_BITMAP_MIG_FLAG_ZEROES        0x02
90 #define DIRTY_BITMAP_MIG_FLAG_BITMAP_NAME   0x04
91 #define DIRTY_BITMAP_MIG_FLAG_DEVICE_NAME   0x08
92 #define DIRTY_BITMAP_MIG_FLAG_START         0x10
93 #define DIRTY_BITMAP_MIG_FLAG_COMPLETE      0x20
94 #define DIRTY_BITMAP_MIG_FLAG_BITS          0x40
95 
96 #define DIRTY_BITMAP_MIG_EXTRA_FLAGS        0x80
97 
98 #define DIRTY_BITMAP_MIG_START_FLAG_ENABLED          0x01
99 #define DIRTY_BITMAP_MIG_START_FLAG_PERSISTENT       0x02
100 /* 0x04 was "AUTOLOAD" flags on elder versions, no it is ignored */
101 #define DIRTY_BITMAP_MIG_START_FLAG_RESERVED_MASK    0xf8
102 
103 typedef struct DirtyBitmapMigBitmapState {
104     /* Written during setup phase. */
105     BlockDriverState *bs;
106     const char *node_name;
107     BdrvDirtyBitmap *bitmap;
108     uint64_t total_sectors;
109     uint64_t sectors_per_chunk;
110     QSIMPLEQ_ENTRY(DirtyBitmapMigBitmapState) entry;
111     uint8_t flags;
112 
113     /* For bulk phase. */
114     bool bulk_completed;
115     uint64_t cur_sector;
116 } DirtyBitmapMigBitmapState;
117 
118 typedef struct DirtyBitmapMigState {
119     QSIMPLEQ_HEAD(, DirtyBitmapMigBitmapState) dbms_list;
120 
121     bool bulk_completed;
122     bool no_bitmaps;
123 
124     /* for send_bitmap_bits() */
125     BlockDriverState *prev_bs;
126     BdrvDirtyBitmap *prev_bitmap;
127 } DirtyBitmapMigState;
128 
129 typedef struct DirtyBitmapLoadState {
130     uint32_t flags;
131     char node_name[256];
132     char bitmap_name[256];
133     BlockDriverState *bs;
134     BdrvDirtyBitmap *bitmap;
135 } DirtyBitmapLoadState;
136 
137 static DirtyBitmapMigState dirty_bitmap_mig_state;
138 
139 typedef struct DirtyBitmapLoadBitmapState {
140     BlockDriverState *bs;
141     BdrvDirtyBitmap *bitmap;
142     bool migrated;
143 } DirtyBitmapLoadBitmapState;
144 static GSList *enabled_bitmaps;
145 QemuMutex finish_lock;
146 
147 void init_dirty_bitmap_incoming_migration(void)
148 {
149     qemu_mutex_init(&finish_lock);
150 }
151 
152 static uint32_t qemu_get_bitmap_flags(QEMUFile *f)
153 {
154     uint8_t flags = qemu_get_byte(f);
155     if (flags & DIRTY_BITMAP_MIG_EXTRA_FLAGS) {
156         flags = flags << 8 | qemu_get_byte(f);
157         if (flags & DIRTY_BITMAP_MIG_EXTRA_FLAGS) {
158             flags = flags << 16 | qemu_get_be16(f);
159         }
160     }
161 
162     return flags;
163 }
164 
165 static void qemu_put_bitmap_flags(QEMUFile *f, uint32_t flags)
166 {
167     /* The code currently do not send flags more than one byte */
168     assert(!(flags & (0xffffff00 | DIRTY_BITMAP_MIG_EXTRA_FLAGS)));
169 
170     qemu_put_byte(f, flags);
171 }
172 
173 static void send_bitmap_header(QEMUFile *f, DirtyBitmapMigBitmapState *dbms,
174                                uint32_t additional_flags)
175 {
176     BlockDriverState *bs = dbms->bs;
177     BdrvDirtyBitmap *bitmap = dbms->bitmap;
178     uint32_t flags = additional_flags;
179     trace_send_bitmap_header_enter();
180 
181     if (bs != dirty_bitmap_mig_state.prev_bs) {
182         dirty_bitmap_mig_state.prev_bs = bs;
183         flags |= DIRTY_BITMAP_MIG_FLAG_DEVICE_NAME;
184     }
185 
186     if (bitmap != dirty_bitmap_mig_state.prev_bitmap) {
187         dirty_bitmap_mig_state.prev_bitmap = bitmap;
188         flags |= DIRTY_BITMAP_MIG_FLAG_BITMAP_NAME;
189     }
190 
191     qemu_put_bitmap_flags(f, flags);
192 
193     if (flags & DIRTY_BITMAP_MIG_FLAG_DEVICE_NAME) {
194         qemu_put_counted_string(f, dbms->node_name);
195     }
196 
197     if (flags & DIRTY_BITMAP_MIG_FLAG_BITMAP_NAME) {
198         qemu_put_counted_string(f, bdrv_dirty_bitmap_name(bitmap));
199     }
200 }
201 
202 static void send_bitmap_start(QEMUFile *f, DirtyBitmapMigBitmapState *dbms)
203 {
204     send_bitmap_header(f, dbms, DIRTY_BITMAP_MIG_FLAG_START);
205     qemu_put_be32(f, bdrv_dirty_bitmap_granularity(dbms->bitmap));
206     qemu_put_byte(f, dbms->flags);
207 }
208 
209 static void send_bitmap_complete(QEMUFile *f, DirtyBitmapMigBitmapState *dbms)
210 {
211     send_bitmap_header(f, dbms, DIRTY_BITMAP_MIG_FLAG_COMPLETE);
212 }
213 
214 static void send_bitmap_bits(QEMUFile *f, DirtyBitmapMigBitmapState *dbms,
215                              uint64_t start_sector, uint32_t nr_sectors)
216 {
217     /* align for buffer_is_zero() */
218     uint64_t align = 4 * sizeof(long);
219     uint64_t unaligned_size =
220         bdrv_dirty_bitmap_serialization_size(
221             dbms->bitmap, start_sector << BDRV_SECTOR_BITS,
222             (uint64_t)nr_sectors << BDRV_SECTOR_BITS);
223     uint64_t buf_size = QEMU_ALIGN_UP(unaligned_size, align);
224     uint8_t *buf = g_malloc0(buf_size);
225     uint32_t flags = DIRTY_BITMAP_MIG_FLAG_BITS;
226 
227     bdrv_dirty_bitmap_serialize_part(
228         dbms->bitmap, buf, start_sector << BDRV_SECTOR_BITS,
229         (uint64_t)nr_sectors << BDRV_SECTOR_BITS);
230 
231     if (buffer_is_zero(buf, buf_size)) {
232         g_free(buf);
233         buf = NULL;
234         flags |= DIRTY_BITMAP_MIG_FLAG_ZEROES;
235     }
236 
237     trace_send_bitmap_bits(flags, start_sector, nr_sectors, buf_size);
238 
239     send_bitmap_header(f, dbms, flags);
240 
241     qemu_put_be64(f, start_sector);
242     qemu_put_be32(f, nr_sectors);
243 
244     /* if a block is zero we need to flush here since the network
245      * bandwidth is now a lot higher than the storage device bandwidth.
246      * thus if we queue zero blocks we slow down the migration. */
247     if (flags & DIRTY_BITMAP_MIG_FLAG_ZEROES) {
248         qemu_fflush(f);
249     } else {
250         qemu_put_be64(f, buf_size);
251         qemu_put_buffer(f, buf, buf_size);
252     }
253 
254     g_free(buf);
255 }
256 
257 /* Called with iothread lock taken.  */
258 static void dirty_bitmap_mig_cleanup(void)
259 {
260     DirtyBitmapMigBitmapState *dbms;
261 
262     while ((dbms = QSIMPLEQ_FIRST(&dirty_bitmap_mig_state.dbms_list)) != NULL) {
263         QSIMPLEQ_REMOVE_HEAD(&dirty_bitmap_mig_state.dbms_list, entry);
264         bdrv_dirty_bitmap_set_busy(dbms->bitmap, false);
265         bdrv_unref(dbms->bs);
266         g_free(dbms);
267     }
268 }
269 
270 /* Called with iothread lock taken. */
271 static int init_dirty_bitmap_migration(void)
272 {
273     BlockDriverState *bs;
274     BdrvDirtyBitmap *bitmap;
275     DirtyBitmapMigBitmapState *dbms;
276     Error *local_err = NULL;
277 
278     dirty_bitmap_mig_state.bulk_completed = false;
279     dirty_bitmap_mig_state.prev_bs = NULL;
280     dirty_bitmap_mig_state.prev_bitmap = NULL;
281     dirty_bitmap_mig_state.no_bitmaps = false;
282 
283     for (bs = bdrv_next_all_states(NULL); bs; bs = bdrv_next_all_states(bs)) {
284         const char *name = bdrv_get_device_or_node_name(bs);
285 
286         for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap;
287              bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
288         {
289             if (!bdrv_dirty_bitmap_name(bitmap)) {
290                 continue;
291             }
292 
293             if (!name || strcmp(name, "") == 0) {
294                 error_report("Found bitmap '%s' in unnamed node %p. It can't "
295                              "be migrated", bdrv_dirty_bitmap_name(bitmap), bs);
296                 goto fail;
297             }
298 
299             if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT,
300                                         &local_err)) {
301                 error_report_err(local_err);
302                 goto fail;
303             }
304 
305             bdrv_ref(bs);
306             bdrv_dirty_bitmap_set_busy(bitmap, true);
307 
308             dbms = g_new0(DirtyBitmapMigBitmapState, 1);
309             dbms->bs = bs;
310             dbms->node_name = name;
311             dbms->bitmap = bitmap;
312             dbms->total_sectors = bdrv_nb_sectors(bs);
313             dbms->sectors_per_chunk = CHUNK_SIZE * 8 *
314                 bdrv_dirty_bitmap_granularity(bitmap) >> BDRV_SECTOR_BITS;
315             if (bdrv_dirty_bitmap_enabled(bitmap)) {
316                 dbms->flags |= DIRTY_BITMAP_MIG_START_FLAG_ENABLED;
317             }
318             if (bdrv_dirty_bitmap_get_persistence(bitmap)) {
319                 dbms->flags |= DIRTY_BITMAP_MIG_START_FLAG_PERSISTENT;
320             }
321 
322             QSIMPLEQ_INSERT_TAIL(&dirty_bitmap_mig_state.dbms_list,
323                                  dbms, entry);
324         }
325     }
326 
327     /* unset migration flags here, to not roll back it */
328     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
329         bdrv_dirty_bitmap_set_migration(dbms->bitmap, true);
330     }
331 
332     if (QSIMPLEQ_EMPTY(&dirty_bitmap_mig_state.dbms_list)) {
333         dirty_bitmap_mig_state.no_bitmaps = true;
334     }
335 
336     return 0;
337 
338 fail:
339     dirty_bitmap_mig_cleanup();
340 
341     return -1;
342 }
343 
344 /* Called with no lock taken.  */
345 static void bulk_phase_send_chunk(QEMUFile *f, DirtyBitmapMigBitmapState *dbms)
346 {
347     uint32_t nr_sectors = MIN(dbms->total_sectors - dbms->cur_sector,
348                              dbms->sectors_per_chunk);
349 
350     send_bitmap_bits(f, dbms, dbms->cur_sector, nr_sectors);
351 
352     dbms->cur_sector += nr_sectors;
353     if (dbms->cur_sector >= dbms->total_sectors) {
354         dbms->bulk_completed = true;
355     }
356 }
357 
358 /* Called with no lock taken.  */
359 static void bulk_phase(QEMUFile *f, bool limit)
360 {
361     DirtyBitmapMigBitmapState *dbms;
362 
363     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
364         while (!dbms->bulk_completed) {
365             bulk_phase_send_chunk(f, dbms);
366             if (limit && qemu_file_rate_limit(f)) {
367                 return;
368             }
369         }
370     }
371 
372     dirty_bitmap_mig_state.bulk_completed = true;
373 }
374 
375 /* for SaveVMHandlers */
376 static void dirty_bitmap_save_cleanup(void *opaque)
377 {
378     dirty_bitmap_mig_cleanup();
379 }
380 
381 static int dirty_bitmap_save_iterate(QEMUFile *f, void *opaque)
382 {
383     trace_dirty_bitmap_save_iterate(migration_in_postcopy());
384 
385     if (migration_in_postcopy() && !dirty_bitmap_mig_state.bulk_completed) {
386         bulk_phase(f, true);
387     }
388 
389     qemu_put_bitmap_flags(f, DIRTY_BITMAP_MIG_FLAG_EOS);
390 
391     return dirty_bitmap_mig_state.bulk_completed;
392 }
393 
394 /* Called with iothread lock taken.  */
395 
396 static int dirty_bitmap_save_complete(QEMUFile *f, void *opaque)
397 {
398     DirtyBitmapMigBitmapState *dbms;
399     trace_dirty_bitmap_save_complete_enter();
400 
401     if (!dirty_bitmap_mig_state.bulk_completed) {
402         bulk_phase(f, false);
403     }
404 
405     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
406         send_bitmap_complete(f, dbms);
407     }
408 
409     qemu_put_bitmap_flags(f, DIRTY_BITMAP_MIG_FLAG_EOS);
410 
411     trace_dirty_bitmap_save_complete_finish();
412 
413     dirty_bitmap_mig_cleanup();
414     return 0;
415 }
416 
417 static void dirty_bitmap_save_pending(QEMUFile *f, void *opaque,
418                                       uint64_t max_size,
419                                       uint64_t *res_precopy_only,
420                                       uint64_t *res_compatible,
421                                       uint64_t *res_postcopy_only)
422 {
423     DirtyBitmapMigBitmapState *dbms;
424     uint64_t pending = 0;
425 
426     qemu_mutex_lock_iothread();
427 
428     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
429         uint64_t gran = bdrv_dirty_bitmap_granularity(dbms->bitmap);
430         uint64_t sectors = dbms->bulk_completed ? 0 :
431                            dbms->total_sectors - dbms->cur_sector;
432 
433         pending += DIV_ROUND_UP(sectors * BDRV_SECTOR_SIZE, gran);
434     }
435 
436     qemu_mutex_unlock_iothread();
437 
438     trace_dirty_bitmap_save_pending(pending, max_size);
439 
440     *res_postcopy_only += pending;
441 }
442 
443 /* First occurrence of this bitmap. It should be created if doesn't exist */
444 static int dirty_bitmap_load_start(QEMUFile *f, DirtyBitmapLoadState *s)
445 {
446     Error *local_err = NULL;
447     uint32_t granularity = qemu_get_be32(f);
448     uint8_t flags = qemu_get_byte(f);
449 
450     if (s->bitmap) {
451         error_report("Bitmap with the same name ('%s') already exists on "
452                      "destination", bdrv_dirty_bitmap_name(s->bitmap));
453         return -EINVAL;
454     } else {
455         s->bitmap = bdrv_create_dirty_bitmap(s->bs, granularity,
456                                              s->bitmap_name, &local_err);
457         if (!s->bitmap) {
458             error_report_err(local_err);
459             return -EINVAL;
460         }
461     }
462 
463     if (flags & DIRTY_BITMAP_MIG_START_FLAG_RESERVED_MASK) {
464         error_report("Unknown flags in migrated dirty bitmap header: %x",
465                      flags);
466         return -EINVAL;
467     }
468 
469     if (flags & DIRTY_BITMAP_MIG_START_FLAG_PERSISTENT) {
470         bdrv_dirty_bitmap_set_persistence(s->bitmap, true);
471     }
472 
473     bdrv_disable_dirty_bitmap(s->bitmap);
474     if (flags & DIRTY_BITMAP_MIG_START_FLAG_ENABLED) {
475         DirtyBitmapLoadBitmapState *b;
476 
477         bdrv_dirty_bitmap_create_successor(s->bs, s->bitmap, &local_err);
478         if (local_err) {
479             error_report_err(local_err);
480             return -EINVAL;
481         }
482 
483         b = g_new(DirtyBitmapLoadBitmapState, 1);
484         b->bs = s->bs;
485         b->bitmap = s->bitmap;
486         b->migrated = false;
487         enabled_bitmaps = g_slist_prepend(enabled_bitmaps, b);
488     }
489 
490     return 0;
491 }
492 
493 void dirty_bitmap_mig_before_vm_start(void)
494 {
495     GSList *item;
496 
497     qemu_mutex_lock(&finish_lock);
498 
499     for (item = enabled_bitmaps; item; item = g_slist_next(item)) {
500         DirtyBitmapLoadBitmapState *b = item->data;
501 
502         if (b->migrated) {
503             bdrv_enable_dirty_bitmap_locked(b->bitmap);
504         } else {
505             bdrv_dirty_bitmap_enable_successor(b->bitmap);
506         }
507 
508         g_free(b);
509     }
510 
511     g_slist_free(enabled_bitmaps);
512     enabled_bitmaps = NULL;
513 
514     qemu_mutex_unlock(&finish_lock);
515 }
516 
517 static void dirty_bitmap_load_complete(QEMUFile *f, DirtyBitmapLoadState *s)
518 {
519     GSList *item;
520     trace_dirty_bitmap_load_complete();
521     bdrv_dirty_bitmap_deserialize_finish(s->bitmap);
522 
523     qemu_mutex_lock(&finish_lock);
524 
525     for (item = enabled_bitmaps; item; item = g_slist_next(item)) {
526         DirtyBitmapLoadBitmapState *b = item->data;
527 
528         if (b->bitmap == s->bitmap) {
529             b->migrated = true;
530             break;
531         }
532     }
533 
534     if (bdrv_dirty_bitmap_has_successor(s->bitmap)) {
535         bdrv_dirty_bitmap_lock(s->bitmap);
536         if (enabled_bitmaps == NULL) {
537             /* in postcopy */
538             bdrv_reclaim_dirty_bitmap_locked(s->bs, s->bitmap, &error_abort);
539             bdrv_enable_dirty_bitmap_locked(s->bitmap);
540         } else {
541             /* target not started, successor must be empty */
542             int64_t count = bdrv_get_dirty_count(s->bitmap);
543             BdrvDirtyBitmap *ret = bdrv_reclaim_dirty_bitmap_locked(s->bs,
544                                                                     s->bitmap,
545                                                                     NULL);
546             /* bdrv_reclaim_dirty_bitmap can fail only on no successor (it
547              * must be) or on merge fail, but merge can't fail when second
548              * bitmap is empty
549              */
550             assert(ret == s->bitmap &&
551                    count == bdrv_get_dirty_count(s->bitmap));
552         }
553         bdrv_dirty_bitmap_unlock(s->bitmap);
554     }
555 
556     qemu_mutex_unlock(&finish_lock);
557 }
558 
559 static int dirty_bitmap_load_bits(QEMUFile *f, DirtyBitmapLoadState *s)
560 {
561     uint64_t first_byte = qemu_get_be64(f) << BDRV_SECTOR_BITS;
562     uint64_t nr_bytes = (uint64_t)qemu_get_be32(f) << BDRV_SECTOR_BITS;
563     trace_dirty_bitmap_load_bits_enter(first_byte >> BDRV_SECTOR_BITS,
564                                        nr_bytes >> BDRV_SECTOR_BITS);
565 
566     if (s->flags & DIRTY_BITMAP_MIG_FLAG_ZEROES) {
567         trace_dirty_bitmap_load_bits_zeroes();
568         bdrv_dirty_bitmap_deserialize_zeroes(s->bitmap, first_byte, nr_bytes,
569                                              false);
570     } else {
571         size_t ret;
572         uint8_t *buf;
573         uint64_t buf_size = qemu_get_be64(f);
574         uint64_t needed_size =
575             bdrv_dirty_bitmap_serialization_size(s->bitmap,
576                                                  first_byte, nr_bytes);
577 
578         if (needed_size > buf_size ||
579             buf_size > QEMU_ALIGN_UP(needed_size, 4 * sizeof(long))
580              /* Here used same alignment as in send_bitmap_bits */
581         ) {
582             error_report("Migrated bitmap granularity doesn't "
583                          "match the destination bitmap '%s' granularity",
584                          bdrv_dirty_bitmap_name(s->bitmap));
585             return -EINVAL;
586         }
587 
588         buf = g_malloc(buf_size);
589         ret = qemu_get_buffer(f, buf, buf_size);
590         if (ret != buf_size) {
591             error_report("Failed to read bitmap bits");
592             g_free(buf);
593             return -EIO;
594         }
595 
596         bdrv_dirty_bitmap_deserialize_part(s->bitmap, buf, first_byte, nr_bytes,
597                                            false);
598         g_free(buf);
599     }
600 
601     return 0;
602 }
603 
604 static int dirty_bitmap_load_header(QEMUFile *f, DirtyBitmapLoadState *s)
605 {
606     Error *local_err = NULL;
607     bool nothing;
608     s->flags = qemu_get_bitmap_flags(f);
609     trace_dirty_bitmap_load_header(s->flags);
610 
611     nothing = s->flags == (s->flags & DIRTY_BITMAP_MIG_FLAG_EOS);
612 
613     if (s->flags & DIRTY_BITMAP_MIG_FLAG_DEVICE_NAME) {
614         if (!qemu_get_counted_string(f, s->node_name)) {
615             error_report("Unable to read node name string");
616             return -EINVAL;
617         }
618         s->bs = bdrv_lookup_bs(s->node_name, s->node_name, &local_err);
619         if (!s->bs) {
620             error_report_err(local_err);
621             return -EINVAL;
622         }
623     } else if (!s->bs && !nothing) {
624         error_report("Error: block device name is not set");
625         return -EINVAL;
626     }
627 
628     if (s->flags & DIRTY_BITMAP_MIG_FLAG_BITMAP_NAME) {
629         if (!qemu_get_counted_string(f, s->bitmap_name)) {
630             error_report("Unable to read bitmap name string");
631             return -EINVAL;
632         }
633         s->bitmap = bdrv_find_dirty_bitmap(s->bs, s->bitmap_name);
634 
635         /* bitmap may be NULL here, it wouldn't be an error if it is the
636          * first occurrence of the bitmap */
637         if (!s->bitmap && !(s->flags & DIRTY_BITMAP_MIG_FLAG_START)) {
638             error_report("Error: unknown dirty bitmap "
639                          "'%s' for block device '%s'",
640                          s->bitmap_name, s->node_name);
641             return -EINVAL;
642         }
643     } else if (!s->bitmap && !nothing) {
644         error_report("Error: block device name is not set");
645         return -EINVAL;
646     }
647 
648     return 0;
649 }
650 
651 static int dirty_bitmap_load(QEMUFile *f, void *opaque, int version_id)
652 {
653     static DirtyBitmapLoadState s;
654     int ret = 0;
655 
656     trace_dirty_bitmap_load_enter();
657 
658     if (version_id != 1) {
659         return -EINVAL;
660     }
661 
662     do {
663         ret = dirty_bitmap_load_header(f, &s);
664         if (ret < 0) {
665             return ret;
666         }
667 
668         if (s.flags & DIRTY_BITMAP_MIG_FLAG_START) {
669             ret = dirty_bitmap_load_start(f, &s);
670         } else if (s.flags & DIRTY_BITMAP_MIG_FLAG_COMPLETE) {
671             dirty_bitmap_load_complete(f, &s);
672         } else if (s.flags & DIRTY_BITMAP_MIG_FLAG_BITS) {
673             ret = dirty_bitmap_load_bits(f, &s);
674         }
675 
676         if (!ret) {
677             ret = qemu_file_get_error(f);
678         }
679 
680         if (ret) {
681             return ret;
682         }
683     } while (!(s.flags & DIRTY_BITMAP_MIG_FLAG_EOS));
684 
685     trace_dirty_bitmap_load_success();
686     return 0;
687 }
688 
689 static int dirty_bitmap_save_setup(QEMUFile *f, void *opaque)
690 {
691     DirtyBitmapMigBitmapState *dbms = NULL;
692     if (init_dirty_bitmap_migration() < 0) {
693         return -1;
694     }
695 
696     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
697         send_bitmap_start(f, dbms);
698     }
699     qemu_put_bitmap_flags(f, DIRTY_BITMAP_MIG_FLAG_EOS);
700 
701     return 0;
702 }
703 
704 static bool dirty_bitmap_is_active(void *opaque)
705 {
706     return migrate_dirty_bitmaps() && !dirty_bitmap_mig_state.no_bitmaps;
707 }
708 
709 static bool dirty_bitmap_is_active_iterate(void *opaque)
710 {
711     return dirty_bitmap_is_active(opaque) && !runstate_is_running();
712 }
713 
714 static bool dirty_bitmap_has_postcopy(void *opaque)
715 {
716     return true;
717 }
718 
719 static SaveVMHandlers savevm_dirty_bitmap_handlers = {
720     .save_setup = dirty_bitmap_save_setup,
721     .save_live_complete_postcopy = dirty_bitmap_save_complete,
722     .save_live_complete_precopy = dirty_bitmap_save_complete,
723     .has_postcopy = dirty_bitmap_has_postcopy,
724     .save_live_pending = dirty_bitmap_save_pending,
725     .save_live_iterate = dirty_bitmap_save_iterate,
726     .is_active_iterate = dirty_bitmap_is_active_iterate,
727     .load_state = dirty_bitmap_load,
728     .save_cleanup = dirty_bitmap_save_cleanup,
729     .is_active = dirty_bitmap_is_active,
730 };
731 
732 void dirty_bitmap_mig_init(void)
733 {
734     QSIMPLEQ_INIT(&dirty_bitmap_mig_state.dbms_list);
735 
736     register_savevm_live(NULL, "dirty-bitmap", 0, 1,
737                          &savevm_dirty_bitmap_handlers,
738                          &dirty_bitmap_mig_state);
739 }
740