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 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 (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_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 | |
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 (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 | |