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_qmp_locked(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     BdrvNextIterator it;
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_first(&it); bs; bs = bdrv_next(&it)) {
284         const char *drive_name = bdrv_get_device_or_node_name(bs);
285 
286         /* skip automatically inserted nodes */
287         while (bs && bs->drv && bs->implicit) {
288             bs = backing_bs(bs);
289         }
290 
291         for (bitmap = bdrv_dirty_bitmap_next(bs, NULL); bitmap;
292              bitmap = bdrv_dirty_bitmap_next(bs, bitmap))
293         {
294             if (!bdrv_dirty_bitmap_name(bitmap)) {
295                 continue;
296             }
297 
298             if (drive_name == NULL) {
299                 error_report("Found bitmap '%s' in unnamed node %p. It can't "
300                              "be migrated", bdrv_dirty_bitmap_name(bitmap), bs);
301                 goto fail;
302             }
303 
304             if (bdrv_dirty_bitmap_user_locked(bitmap)) {
305                 error_report("Can't migrate a bitmap that is in use by another operation: '%s'",
306                              bdrv_dirty_bitmap_name(bitmap));
307                 goto fail;
308             }
309 
310             if (bdrv_dirty_bitmap_readonly(bitmap)) {
311                 error_report("Can't migrate read-only dirty bitmap: '%s",
312                              bdrv_dirty_bitmap_name(bitmap));
313                 goto fail;
314             }
315 
316             bdrv_ref(bs);
317             bdrv_dirty_bitmap_set_qmp_locked(bitmap, true);
318 
319             dbms = g_new0(DirtyBitmapMigBitmapState, 1);
320             dbms->bs = bs;
321             dbms->node_name = drive_name;
322             dbms->bitmap = bitmap;
323             dbms->total_sectors = bdrv_nb_sectors(bs);
324             dbms->sectors_per_chunk = CHUNK_SIZE * 8 *
325                 bdrv_dirty_bitmap_granularity(bitmap) >> BDRV_SECTOR_BITS;
326             if (bdrv_dirty_bitmap_enabled(bitmap)) {
327                 dbms->flags |= DIRTY_BITMAP_MIG_START_FLAG_ENABLED;
328             }
329             if (bdrv_dirty_bitmap_get_persistance(bitmap)) {
330                 dbms->flags |= DIRTY_BITMAP_MIG_START_FLAG_PERSISTENT;
331             }
332 
333             QSIMPLEQ_INSERT_TAIL(&dirty_bitmap_mig_state.dbms_list,
334                                  dbms, entry);
335         }
336     }
337 
338     /* unset migration flags here, to not roll back it */
339     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
340         bdrv_dirty_bitmap_set_migration(dbms->bitmap, true);
341     }
342 
343     if (QSIMPLEQ_EMPTY(&dirty_bitmap_mig_state.dbms_list)) {
344         dirty_bitmap_mig_state.no_bitmaps = true;
345     }
346 
347     return 0;
348 
349 fail:
350     dirty_bitmap_mig_cleanup();
351 
352     return -1;
353 }
354 
355 /* Called with no lock taken.  */
356 static void bulk_phase_send_chunk(QEMUFile *f, DirtyBitmapMigBitmapState *dbms)
357 {
358     uint32_t nr_sectors = MIN(dbms->total_sectors - dbms->cur_sector,
359                              dbms->sectors_per_chunk);
360 
361     send_bitmap_bits(f, dbms, dbms->cur_sector, nr_sectors);
362 
363     dbms->cur_sector += nr_sectors;
364     if (dbms->cur_sector >= dbms->total_sectors) {
365         dbms->bulk_completed = true;
366     }
367 }
368 
369 /* Called with no lock taken.  */
370 static void bulk_phase(QEMUFile *f, bool limit)
371 {
372     DirtyBitmapMigBitmapState *dbms;
373 
374     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
375         while (!dbms->bulk_completed) {
376             bulk_phase_send_chunk(f, dbms);
377             if (limit && qemu_file_rate_limit(f)) {
378                 return;
379             }
380         }
381     }
382 
383     dirty_bitmap_mig_state.bulk_completed = true;
384 }
385 
386 /* for SaveVMHandlers */
387 static void dirty_bitmap_save_cleanup(void *opaque)
388 {
389     dirty_bitmap_mig_cleanup();
390 }
391 
392 static int dirty_bitmap_save_iterate(QEMUFile *f, void *opaque)
393 {
394     trace_dirty_bitmap_save_iterate(migration_in_postcopy());
395 
396     if (migration_in_postcopy() && !dirty_bitmap_mig_state.bulk_completed) {
397         bulk_phase(f, true);
398     }
399 
400     qemu_put_bitmap_flags(f, DIRTY_BITMAP_MIG_FLAG_EOS);
401 
402     return dirty_bitmap_mig_state.bulk_completed;
403 }
404 
405 /* Called with iothread lock taken.  */
406 
407 static int dirty_bitmap_save_complete(QEMUFile *f, void *opaque)
408 {
409     DirtyBitmapMigBitmapState *dbms;
410     trace_dirty_bitmap_save_complete_enter();
411 
412     if (!dirty_bitmap_mig_state.bulk_completed) {
413         bulk_phase(f, false);
414     }
415 
416     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
417         send_bitmap_complete(f, dbms);
418     }
419 
420     qemu_put_bitmap_flags(f, DIRTY_BITMAP_MIG_FLAG_EOS);
421 
422     trace_dirty_bitmap_save_complete_finish();
423 
424     dirty_bitmap_mig_cleanup();
425     return 0;
426 }
427 
428 static void dirty_bitmap_save_pending(QEMUFile *f, void *opaque,
429                                       uint64_t max_size,
430                                       uint64_t *res_precopy_only,
431                                       uint64_t *res_compatible,
432                                       uint64_t *res_postcopy_only)
433 {
434     DirtyBitmapMigBitmapState *dbms;
435     uint64_t pending = 0;
436 
437     qemu_mutex_lock_iothread();
438 
439     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
440         uint64_t gran = bdrv_dirty_bitmap_granularity(dbms->bitmap);
441         uint64_t sectors = dbms->bulk_completed ? 0 :
442                            dbms->total_sectors - dbms->cur_sector;
443 
444         pending += DIV_ROUND_UP(sectors * BDRV_SECTOR_SIZE, gran);
445     }
446 
447     qemu_mutex_unlock_iothread();
448 
449     trace_dirty_bitmap_save_pending(pending, max_size);
450 
451     *res_postcopy_only += pending;
452 }
453 
454 /* First occurrence of this bitmap. It should be created if doesn't exist */
455 static int dirty_bitmap_load_start(QEMUFile *f, DirtyBitmapLoadState *s)
456 {
457     Error *local_err = NULL;
458     uint32_t granularity = qemu_get_be32(f);
459     uint8_t flags = qemu_get_byte(f);
460 
461     if (s->bitmap) {
462         error_report("Bitmap with the same name ('%s') already exists on "
463                      "destination", bdrv_dirty_bitmap_name(s->bitmap));
464         return -EINVAL;
465     } else {
466         s->bitmap = bdrv_create_dirty_bitmap(s->bs, granularity,
467                                              s->bitmap_name, &local_err);
468         if (!s->bitmap) {
469             error_report_err(local_err);
470             return -EINVAL;
471         }
472     }
473 
474     if (flags & DIRTY_BITMAP_MIG_START_FLAG_RESERVED_MASK) {
475         error_report("Unknown flags in migrated dirty bitmap header: %x",
476                      flags);
477         return -EINVAL;
478     }
479 
480     if (flags & DIRTY_BITMAP_MIG_START_FLAG_PERSISTENT) {
481         bdrv_dirty_bitmap_set_persistance(s->bitmap, true);
482     }
483 
484     bdrv_disable_dirty_bitmap(s->bitmap);
485     if (flags & DIRTY_BITMAP_MIG_START_FLAG_ENABLED) {
486         DirtyBitmapLoadBitmapState *b;
487 
488         bdrv_dirty_bitmap_create_successor(s->bs, s->bitmap, &local_err);
489         if (local_err) {
490             error_report_err(local_err);
491             return -EINVAL;
492         }
493 
494         b = g_new(DirtyBitmapLoadBitmapState, 1);
495         b->bs = s->bs;
496         b->bitmap = s->bitmap;
497         b->migrated = false;
498         enabled_bitmaps = g_slist_prepend(enabled_bitmaps, b);
499     }
500 
501     return 0;
502 }
503 
504 void dirty_bitmap_mig_before_vm_start(void)
505 {
506     GSList *item;
507 
508     qemu_mutex_lock(&finish_lock);
509 
510     for (item = enabled_bitmaps; item; item = g_slist_next(item)) {
511         DirtyBitmapLoadBitmapState *b = item->data;
512 
513         if (b->migrated) {
514             bdrv_enable_dirty_bitmap_locked(b->bitmap);
515         } else {
516             bdrv_dirty_bitmap_enable_successor(b->bitmap);
517         }
518 
519         g_free(b);
520     }
521 
522     g_slist_free(enabled_bitmaps);
523     enabled_bitmaps = NULL;
524 
525     qemu_mutex_unlock(&finish_lock);
526 }
527 
528 static void dirty_bitmap_load_complete(QEMUFile *f, DirtyBitmapLoadState *s)
529 {
530     GSList *item;
531     trace_dirty_bitmap_load_complete();
532     bdrv_dirty_bitmap_deserialize_finish(s->bitmap);
533 
534     qemu_mutex_lock(&finish_lock);
535 
536     for (item = enabled_bitmaps; item; item = g_slist_next(item)) {
537         DirtyBitmapLoadBitmapState *b = item->data;
538 
539         if (b->bitmap == s->bitmap) {
540             b->migrated = true;
541             break;
542         }
543     }
544 
545     if (bdrv_dirty_bitmap_frozen(s->bitmap)) {
546         bdrv_dirty_bitmap_lock(s->bitmap);
547         if (enabled_bitmaps == NULL) {
548             /* in postcopy */
549             bdrv_reclaim_dirty_bitmap_locked(s->bs, s->bitmap, &error_abort);
550             bdrv_enable_dirty_bitmap_locked(s->bitmap);
551         } else {
552             /* target not started, successor must be empty */
553             int64_t count = bdrv_get_dirty_count(s->bitmap);
554             BdrvDirtyBitmap *ret = bdrv_reclaim_dirty_bitmap_locked(s->bs,
555                                                                     s->bitmap,
556                                                                     NULL);
557             /* bdrv_reclaim_dirty_bitmap can fail only on no successor (it
558              * must be) or on merge fail, but merge can't fail when second
559              * bitmap is empty
560              */
561             assert(ret == s->bitmap &&
562                    count == bdrv_get_dirty_count(s->bitmap));
563         }
564         bdrv_dirty_bitmap_unlock(s->bitmap);
565     }
566 
567     qemu_mutex_unlock(&finish_lock);
568 }
569 
570 static int dirty_bitmap_load_bits(QEMUFile *f, DirtyBitmapLoadState *s)
571 {
572     uint64_t first_byte = qemu_get_be64(f) << BDRV_SECTOR_BITS;
573     uint64_t nr_bytes = (uint64_t)qemu_get_be32(f) << BDRV_SECTOR_BITS;
574     trace_dirty_bitmap_load_bits_enter(first_byte >> BDRV_SECTOR_BITS,
575                                        nr_bytes >> BDRV_SECTOR_BITS);
576 
577     if (s->flags & DIRTY_BITMAP_MIG_FLAG_ZEROES) {
578         trace_dirty_bitmap_load_bits_zeroes();
579         bdrv_dirty_bitmap_deserialize_zeroes(s->bitmap, first_byte, nr_bytes,
580                                              false);
581     } else {
582         size_t ret;
583         uint8_t *buf;
584         uint64_t buf_size = qemu_get_be64(f);
585         uint64_t needed_size =
586             bdrv_dirty_bitmap_serialization_size(s->bitmap,
587                                                  first_byte, nr_bytes);
588 
589         if (needed_size > buf_size ||
590             buf_size > QEMU_ALIGN_UP(needed_size, 4 * sizeof(long))
591              /* Here used same alignment as in send_bitmap_bits */
592         ) {
593             error_report("Migrated bitmap granularity doesn't "
594                          "match the destination bitmap '%s' granularity",
595                          bdrv_dirty_bitmap_name(s->bitmap));
596             return -EINVAL;
597         }
598 
599         buf = g_malloc(buf_size);
600         ret = qemu_get_buffer(f, buf, buf_size);
601         if (ret != buf_size) {
602             error_report("Failed to read bitmap bits");
603             g_free(buf);
604             return -EIO;
605         }
606 
607         bdrv_dirty_bitmap_deserialize_part(s->bitmap, buf, first_byte, nr_bytes,
608                                            false);
609         g_free(buf);
610     }
611 
612     return 0;
613 }
614 
615 static int dirty_bitmap_load_header(QEMUFile *f, DirtyBitmapLoadState *s)
616 {
617     Error *local_err = NULL;
618     bool nothing;
619     s->flags = qemu_get_bitmap_flags(f);
620     trace_dirty_bitmap_load_header(s->flags);
621 
622     nothing = s->flags == (s->flags & DIRTY_BITMAP_MIG_FLAG_EOS);
623 
624     if (s->flags & DIRTY_BITMAP_MIG_FLAG_DEVICE_NAME) {
625         if (!qemu_get_counted_string(f, s->node_name)) {
626             error_report("Unable to read node name string");
627             return -EINVAL;
628         }
629         s->bs = bdrv_lookup_bs(s->node_name, s->node_name, &local_err);
630         if (!s->bs) {
631             error_report_err(local_err);
632             return -EINVAL;
633         }
634     } else if (!s->bs && !nothing) {
635         error_report("Error: block device name is not set");
636         return -EINVAL;
637     }
638 
639     if (s->flags & DIRTY_BITMAP_MIG_FLAG_BITMAP_NAME) {
640         if (!qemu_get_counted_string(f, s->bitmap_name)) {
641             error_report("Unable to read bitmap name string");
642             return -EINVAL;
643         }
644         s->bitmap = bdrv_find_dirty_bitmap(s->bs, s->bitmap_name);
645 
646         /* bitmap may be NULL here, it wouldn't be an error if it is the
647          * first occurrence of the bitmap */
648         if (!s->bitmap && !(s->flags & DIRTY_BITMAP_MIG_FLAG_START)) {
649             error_report("Error: unknown dirty bitmap "
650                          "'%s' for block device '%s'",
651                          s->bitmap_name, s->node_name);
652             return -EINVAL;
653         }
654     } else if (!s->bitmap && !nothing) {
655         error_report("Error: block device name is not set");
656         return -EINVAL;
657     }
658 
659     return 0;
660 }
661 
662 static int dirty_bitmap_load(QEMUFile *f, void *opaque, int version_id)
663 {
664     static DirtyBitmapLoadState s;
665     int ret = 0;
666 
667     trace_dirty_bitmap_load_enter();
668 
669     if (version_id != 1) {
670         return -EINVAL;
671     }
672 
673     do {
674         ret = dirty_bitmap_load_header(f, &s);
675         if (ret < 0) {
676             return ret;
677         }
678 
679         if (s.flags & DIRTY_BITMAP_MIG_FLAG_START) {
680             ret = dirty_bitmap_load_start(f, &s);
681         } else if (s.flags & DIRTY_BITMAP_MIG_FLAG_COMPLETE) {
682             dirty_bitmap_load_complete(f, &s);
683         } else if (s.flags & DIRTY_BITMAP_MIG_FLAG_BITS) {
684             ret = dirty_bitmap_load_bits(f, &s);
685         }
686 
687         if (!ret) {
688             ret = qemu_file_get_error(f);
689         }
690 
691         if (ret) {
692             return ret;
693         }
694     } while (!(s.flags & DIRTY_BITMAP_MIG_FLAG_EOS));
695 
696     trace_dirty_bitmap_load_success();
697     return 0;
698 }
699 
700 static int dirty_bitmap_save_setup(QEMUFile *f, void *opaque)
701 {
702     DirtyBitmapMigBitmapState *dbms = NULL;
703     if (init_dirty_bitmap_migration() < 0) {
704         return -1;
705     }
706 
707     QSIMPLEQ_FOREACH(dbms, &dirty_bitmap_mig_state.dbms_list, entry) {
708         send_bitmap_start(f, dbms);
709     }
710     qemu_put_bitmap_flags(f, DIRTY_BITMAP_MIG_FLAG_EOS);
711 
712     return 0;
713 }
714 
715 static bool dirty_bitmap_is_active(void *opaque)
716 {
717     return migrate_dirty_bitmaps() && !dirty_bitmap_mig_state.no_bitmaps;
718 }
719 
720 static bool dirty_bitmap_is_active_iterate(void *opaque)
721 {
722     return dirty_bitmap_is_active(opaque) && !runstate_is_running();
723 }
724 
725 static bool dirty_bitmap_has_postcopy(void *opaque)
726 {
727     return true;
728 }
729 
730 static SaveVMHandlers savevm_dirty_bitmap_handlers = {
731     .save_setup = dirty_bitmap_save_setup,
732     .save_live_complete_postcopy = dirty_bitmap_save_complete,
733     .save_live_complete_precopy = dirty_bitmap_save_complete,
734     .has_postcopy = dirty_bitmap_has_postcopy,
735     .save_live_pending = dirty_bitmap_save_pending,
736     .save_live_iterate = dirty_bitmap_save_iterate,
737     .is_active_iterate = dirty_bitmap_is_active_iterate,
738     .load_state = dirty_bitmap_load,
739     .save_cleanup = dirty_bitmap_save_cleanup,
740     .is_active = dirty_bitmap_is_active,
741 };
742 
743 void dirty_bitmap_mig_init(void)
744 {
745     QSIMPLEQ_INIT(&dirty_bitmap_mig_state.dbms_list);
746 
747     register_savevm_live(NULL, "dirty-bitmap", 0, 1,
748                          &savevm_dirty_bitmap_handlers,
749                          &dirty_bitmap_mig_state);
750 }
751