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 "sysemu/runstate.h"
66#include "qemu/main-loop.h"
67#include "qemu/error-report.h"
68#include "migration/misc.h"
69#include "migration/migration.h"
70#include "qemu-file.h"
71#include "migration/vmstate.h"
72#include "migration/register.h"
73#include "qemu/hbitmap.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
103typedef 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
118typedef 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
129typedef 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
137static DirtyBitmapMigState dirty_bitmap_mig_state;
138
139typedef struct DirtyBitmapLoadBitmapState {
140 BlockDriverState *bs;
141 BdrvDirtyBitmap *bitmap;
142 bool migrated;
143} DirtyBitmapLoadBitmapState;
144static GSList *enabled_bitmaps;
145QemuMutex finish_lock;
146
147void init_dirty_bitmap_incoming_migration(void)
148{
149 qemu_mutex_init(&finish_lock);
150}
151
152static 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
165static 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
173static 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
202static 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
209static void send_bitmap_complete(QEMUFile *f, DirtyBitmapMigBitmapState *dbms)
210{
211 send_bitmap_header(f, dbms, DIRTY_BITMAP_MIG_FLAG_COMPLETE);
212}
213
214static 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. */
258static 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. */
271static 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_skip_store(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
338fail:
339 dirty_bitmap_mig_cleanup();
340
341 return -1;
342}
343
344/* Called with no lock taken. */
345static 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. */
359static 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 */
376static void dirty_bitmap_save_cleanup(void *opaque)
377{
378 dirty_bitmap_mig_cleanup();
379}
380
381static 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
396static 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
417static 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 */
444static 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
493void 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
517static 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
559static 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
604static 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
651static 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
689static 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
704static bool dirty_bitmap_is_active(void *opaque)
705{
706 return migrate_dirty_bitmaps() && !dirty_bitmap_mig_state.no_bitmaps;
707}
708
709static bool dirty_bitmap_is_active_iterate(void *opaque)
710{
711 return dirty_bitmap_is_active(opaque) && !runstate_is_running();
712}
713
714static bool dirty_bitmap_has_postcopy(void *opaque)
715{
716 return true;
717}
718
719static 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
732void 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