2 * QEMU live block migration
4 * Copyright IBM, Corp. 2009
7 * Liran Schour <lirans@il.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
14 #include "qemu-common.h"
15 #include "block_int.h"
17 #include "qemu-queue.h"
18 #include "qemu-timer.h"
20 #include "block-migration.h"
21 #include "migration.h"
25 #define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)
27 #define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
28 #define BLK_MIG_FLAG_EOS 0x02
29 #define BLK_MIG_FLAG_PROGRESS 0x04
31 #define MAX_IS_ALLOCATED_SEARCH 65536
33 //#define DEBUG_BLK_MIGRATION
35 #ifdef DEBUG_BLK_MIGRATION
36 #define DPRINTF(fmt, ...) \
37 do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0)
39 #define DPRINTF(fmt, ...) \
43 typedef struct BlkMigDevState
{
49 int64_t completed_sectors
;
50 int64_t total_sectors
;
52 QSIMPLEQ_ENTRY(BlkMigDevState
) entry
;
53 unsigned long *aio_bitmap
;
56 typedef struct BlkMigBlock
{
63 BlockDriverAIOCB
*aiocb
;
65 QSIMPLEQ_ENTRY(BlkMigBlock
) entry
;
68 typedef struct BlkMigState
{
71 QSIMPLEQ_HEAD(bmds_list
, BlkMigDevState
) bmds_list
;
72 QSIMPLEQ_HEAD(blk_list
, BlkMigBlock
) blk_list
;
76 int64_t total_sector_sum
;
79 long double total_time
;
80 long double prev_time_offset
;
84 static BlkMigState block_mig_state
;
86 static void blk_send(QEMUFile
*f
, BlkMigBlock
* blk
)
90 /* sector number and flags */
91 qemu_put_be64(f
, (blk
->sector
<< BDRV_SECTOR_BITS
)
92 | BLK_MIG_FLAG_DEVICE_BLOCK
);
95 len
= strlen(blk
->bmds
->bs
->device_name
);
96 qemu_put_byte(f
, len
);
97 qemu_put_buffer(f
, (uint8_t *)blk
->bmds
->bs
->device_name
, len
);
99 qemu_put_buffer(f
, blk
->buf
, BLOCK_SIZE
);
102 int blk_mig_active(void)
104 return !QSIMPLEQ_EMPTY(&block_mig_state
.bmds_list
);
107 uint64_t blk_mig_bytes_transferred(void)
109 BlkMigDevState
*bmds
;
112 QSIMPLEQ_FOREACH(bmds
, &block_mig_state
.bmds_list
, entry
) {
113 sum
+= bmds
->completed_sectors
;
115 return sum
<< BDRV_SECTOR_BITS
;
118 uint64_t blk_mig_bytes_remaining(void)
120 return blk_mig_bytes_total() - blk_mig_bytes_transferred();
123 uint64_t blk_mig_bytes_total(void)
125 BlkMigDevState
*bmds
;
128 QSIMPLEQ_FOREACH(bmds
, &block_mig_state
.bmds_list
, entry
) {
129 sum
+= bmds
->total_sectors
;
131 return sum
<< BDRV_SECTOR_BITS
;
134 static inline long double compute_read_bwidth(void)
136 assert(block_mig_state
.total_time
!= 0);
137 return (block_mig_state
.reads
/ block_mig_state
.total_time
) * BLOCK_SIZE
;
140 static int bmds_aio_inflight(BlkMigDevState
*bmds
, int64_t sector
)
142 int64_t chunk
= sector
/ (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
;
144 if ((sector
<< BDRV_SECTOR_BITS
) < bdrv_getlength(bmds
->bs
)) {
145 return !!(bmds
->aio_bitmap
[chunk
/ (sizeof(unsigned long) * 8)] &
146 (1UL << (chunk
% (sizeof(unsigned long) * 8))));
152 static void bmds_set_aio_inflight(BlkMigDevState
*bmds
, int64_t sector_num
,
153 int nb_sectors
, int set
)
156 unsigned long val
, idx
, bit
;
158 start
= sector_num
/ BDRV_SECTORS_PER_DIRTY_CHUNK
;
159 end
= (sector_num
+ nb_sectors
- 1) / BDRV_SECTORS_PER_DIRTY_CHUNK
;
161 for (; start
<= end
; start
++) {
162 idx
= start
/ (sizeof(unsigned long) * 8);
163 bit
= start
% (sizeof(unsigned long) * 8);
164 val
= bmds
->aio_bitmap
[idx
];
168 val
&= ~(1UL << bit
);
170 bmds
->aio_bitmap
[idx
] = val
;
174 static void alloc_aio_bitmap(BlkMigDevState
*bmds
)
176 BlockDriverState
*bs
= bmds
->bs
;
179 bitmap_size
= (bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
) +
180 BDRV_SECTORS_PER_DIRTY_CHUNK
* 8 - 1;
181 bitmap_size
/= BDRV_SECTORS_PER_DIRTY_CHUNK
* 8;
183 bmds
->aio_bitmap
= qemu_mallocz(bitmap_size
);
186 static void blk_mig_read_cb(void *opaque
, int ret
)
188 long double curr_time
= qemu_get_clock_ns(rt_clock
);
189 BlkMigBlock
*blk
= opaque
;
193 block_mig_state
.reads
++;
194 block_mig_state
.total_time
+= (curr_time
- block_mig_state
.prev_time_offset
);
195 block_mig_state
.prev_time_offset
= curr_time
;
197 QSIMPLEQ_INSERT_TAIL(&block_mig_state
.blk_list
, blk
, entry
);
198 bmds_set_aio_inflight(blk
->bmds
, blk
->sector
, blk
->nr_sectors
, 0);
200 block_mig_state
.submitted
--;
201 block_mig_state
.read_done
++;
202 assert(block_mig_state
.submitted
>= 0);
205 static int mig_save_device_bulk(Monitor
*mon
, QEMUFile
*f
,
206 BlkMigDevState
*bmds
)
208 int64_t total_sectors
= bmds
->total_sectors
;
209 int64_t cur_sector
= bmds
->cur_sector
;
210 BlockDriverState
*bs
= bmds
->bs
;
214 if (bmds
->shared_base
) {
215 while (cur_sector
< total_sectors
&&
216 !bdrv_is_allocated(bs
, cur_sector
, MAX_IS_ALLOCATED_SEARCH
,
218 cur_sector
+= nr_sectors
;
222 if (cur_sector
>= total_sectors
) {
223 bmds
->cur_sector
= bmds
->completed_sectors
= total_sectors
;
227 bmds
->completed_sectors
= cur_sector
;
229 cur_sector
&= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK
- 1);
231 /* we are going to transfer a full block even if it is not allocated */
232 nr_sectors
= BDRV_SECTORS_PER_DIRTY_CHUNK
;
234 if (total_sectors
- cur_sector
< BDRV_SECTORS_PER_DIRTY_CHUNK
) {
235 nr_sectors
= total_sectors
- cur_sector
;
238 blk
= qemu_malloc(sizeof(BlkMigBlock
));
239 blk
->buf
= qemu_malloc(BLOCK_SIZE
);
241 blk
->sector
= cur_sector
;
242 blk
->nr_sectors
= nr_sectors
;
244 blk
->iov
.iov_base
= blk
->buf
;
245 blk
->iov
.iov_len
= nr_sectors
* BDRV_SECTOR_SIZE
;
246 qemu_iovec_init_external(&blk
->qiov
, &blk
->iov
, 1);
248 if (block_mig_state
.submitted
== 0) {
249 block_mig_state
.prev_time_offset
= qemu_get_clock_ns(rt_clock
);
252 blk
->aiocb
= bdrv_aio_readv(bs
, cur_sector
, &blk
->qiov
,
253 nr_sectors
, blk_mig_read_cb
, blk
);
257 block_mig_state
.submitted
++;
259 bdrv_reset_dirty(bs
, cur_sector
, nr_sectors
);
260 bmds
->cur_sector
= cur_sector
+ nr_sectors
;
262 return (bmds
->cur_sector
>= total_sectors
);
265 monitor_printf(mon
, "Error reading sector %" PRId64
"\n", cur_sector
);
266 qemu_file_set_error(f
);
272 static void set_dirty_tracking(int enable
)
274 BlkMigDevState
*bmds
;
276 QSIMPLEQ_FOREACH(bmds
, &block_mig_state
.bmds_list
, entry
) {
277 bdrv_set_dirty_tracking(bmds
->bs
, enable
);
281 static void init_blk_migration_it(void *opaque
, BlockDriverState
*bs
)
283 Monitor
*mon
= opaque
;
284 BlkMigDevState
*bmds
;
287 if (!bdrv_is_read_only(bs
)) {
288 sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
293 bmds
= qemu_mallocz(sizeof(BlkMigDevState
));
295 bmds
->bulk_completed
= 0;
296 bmds
->total_sectors
= sectors
;
297 bmds
->completed_sectors
= 0;
298 bmds
->shared_base
= block_mig_state
.shared_base
;
299 alloc_aio_bitmap(bmds
);
300 drive_get_ref(drive_get_by_blockdev(bs
));
301 bdrv_set_in_use(bs
, 1);
303 block_mig_state
.total_sector_sum
+= sectors
;
305 if (bmds
->shared_base
) {
306 monitor_printf(mon
, "Start migration for %s with shared base "
310 monitor_printf(mon
, "Start full migration for %s\n",
314 QSIMPLEQ_INSERT_TAIL(&block_mig_state
.bmds_list
, bmds
, entry
);
318 static void init_blk_migration(Monitor
*mon
, QEMUFile
*f
)
320 block_mig_state
.submitted
= 0;
321 block_mig_state
.read_done
= 0;
322 block_mig_state
.transferred
= 0;
323 block_mig_state
.total_sector_sum
= 0;
324 block_mig_state
.prev_progress
= -1;
325 block_mig_state
.bulk_completed
= 0;
326 block_mig_state
.total_time
= 0;
327 block_mig_state
.reads
= 0;
329 bdrv_iterate(init_blk_migration_it
, mon
);
332 static int blk_mig_save_bulked_block(Monitor
*mon
, QEMUFile
*f
)
334 int64_t completed_sector_sum
= 0;
335 BlkMigDevState
*bmds
;
339 QSIMPLEQ_FOREACH(bmds
, &block_mig_state
.bmds_list
, entry
) {
340 if (bmds
->bulk_completed
== 0) {
341 if (mig_save_device_bulk(mon
, f
, bmds
) == 1) {
342 /* completed bulk section for this device */
343 bmds
->bulk_completed
= 1;
345 completed_sector_sum
+= bmds
->completed_sectors
;
349 completed_sector_sum
+= bmds
->completed_sectors
;
353 if (block_mig_state
.total_sector_sum
!= 0) {
354 progress
= completed_sector_sum
* 100 /
355 block_mig_state
.total_sector_sum
;
359 if (progress
!= block_mig_state
.prev_progress
) {
360 block_mig_state
.prev_progress
= progress
;
361 qemu_put_be64(f
, (progress
<< BDRV_SECTOR_BITS
)
362 | BLK_MIG_FLAG_PROGRESS
);
363 monitor_printf(mon
, "Completed %d %%\r", progress
);
370 static void blk_mig_reset_dirty_cursor(void)
372 BlkMigDevState
*bmds
;
374 QSIMPLEQ_FOREACH(bmds
, &block_mig_state
.bmds_list
, entry
) {
379 static int mig_save_device_dirty(Monitor
*mon
, QEMUFile
*f
,
380 BlkMigDevState
*bmds
, int is_async
)
383 int64_t total_sectors
= bmds
->total_sectors
;
387 for (sector
= bmds
->cur_dirty
; sector
< bmds
->total_sectors
;) {
388 if (bmds_aio_inflight(bmds
, sector
)) {
391 if (bdrv_get_dirty(bmds
->bs
, sector
)) {
393 if (total_sectors
- sector
< BDRV_SECTORS_PER_DIRTY_CHUNK
) {
394 nr_sectors
= total_sectors
- sector
;
396 nr_sectors
= BDRV_SECTORS_PER_DIRTY_CHUNK
;
398 blk
= qemu_malloc(sizeof(BlkMigBlock
));
399 blk
->buf
= qemu_malloc(BLOCK_SIZE
);
401 blk
->sector
= sector
;
402 blk
->nr_sectors
= nr_sectors
;
405 blk
->iov
.iov_base
= blk
->buf
;
406 blk
->iov
.iov_len
= nr_sectors
* BDRV_SECTOR_SIZE
;
407 qemu_iovec_init_external(&blk
->qiov
, &blk
->iov
, 1);
409 if (block_mig_state
.submitted
== 0) {
410 block_mig_state
.prev_time_offset
= qemu_get_clock_ns(rt_clock
);
413 blk
->aiocb
= bdrv_aio_readv(bmds
->bs
, sector
, &blk
->qiov
,
414 nr_sectors
, blk_mig_read_cb
, blk
);
418 block_mig_state
.submitted
++;
419 bmds_set_aio_inflight(bmds
, sector
, nr_sectors
, 1);
421 if (bdrv_read(bmds
->bs
, sector
, blk
->buf
,
431 bdrv_reset_dirty(bmds
->bs
, sector
, nr_sectors
);
434 sector
+= BDRV_SECTORS_PER_DIRTY_CHUNK
;
435 bmds
->cur_dirty
= sector
;
438 return (bmds
->cur_dirty
>= bmds
->total_sectors
);
441 monitor_printf(mon
, "Error reading sector %" PRId64
"\n", sector
);
442 qemu_file_set_error(f
);
448 static int blk_mig_save_dirty_block(Monitor
*mon
, QEMUFile
*f
, int is_async
)
450 BlkMigDevState
*bmds
;
453 QSIMPLEQ_FOREACH(bmds
, &block_mig_state
.bmds_list
, entry
) {
454 if (mig_save_device_dirty(mon
, f
, bmds
, is_async
) == 0) {
463 static void flush_blks(QEMUFile
* f
)
467 DPRINTF("%s Enter submitted %d read_done %d transferred %d\n",
468 __FUNCTION__
, block_mig_state
.submitted
, block_mig_state
.read_done
,
469 block_mig_state
.transferred
);
471 while ((blk
= QSIMPLEQ_FIRST(&block_mig_state
.blk_list
)) != NULL
) {
472 if (qemu_file_rate_limit(f
)) {
476 qemu_file_set_error(f
);
481 QSIMPLEQ_REMOVE_HEAD(&block_mig_state
.blk_list
, entry
);
485 block_mig_state
.read_done
--;
486 block_mig_state
.transferred
++;
487 assert(block_mig_state
.read_done
>= 0);
490 DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__
,
491 block_mig_state
.submitted
, block_mig_state
.read_done
,
492 block_mig_state
.transferred
);
495 static int64_t get_remaining_dirty(void)
497 BlkMigDevState
*bmds
;
500 QSIMPLEQ_FOREACH(bmds
, &block_mig_state
.bmds_list
, entry
) {
501 dirty
+= bdrv_get_dirty_count(bmds
->bs
);
504 return dirty
* BLOCK_SIZE
;
507 static int is_stage2_completed(void)
509 int64_t remaining_dirty
;
512 if (block_mig_state
.bulk_completed
== 1) {
514 remaining_dirty
= get_remaining_dirty();
515 if (remaining_dirty
== 0) {
519 bwidth
= compute_read_bwidth();
521 if ((remaining_dirty
/ bwidth
) <=
522 migrate_max_downtime()) {
523 /* finish stage2 because we think that we can finish remaing work
524 below max_downtime */
533 static void blk_mig_cleanup(Monitor
*mon
)
535 BlkMigDevState
*bmds
;
538 set_dirty_tracking(0);
540 while ((bmds
= QSIMPLEQ_FIRST(&block_mig_state
.bmds_list
)) != NULL
) {
541 QSIMPLEQ_REMOVE_HEAD(&block_mig_state
.bmds_list
, entry
);
542 bdrv_set_in_use(bmds
->bs
, 0);
543 drive_put_ref(drive_get_by_blockdev(bmds
->bs
));
544 qemu_free(bmds
->aio_bitmap
);
548 while ((blk
= QSIMPLEQ_FIRST(&block_mig_state
.blk_list
)) != NULL
) {
549 QSIMPLEQ_REMOVE_HEAD(&block_mig_state
.blk_list
, entry
);
554 monitor_printf(mon
, "\n");
557 static int block_save_live(Monitor
*mon
, QEMUFile
*f
, int stage
, void *opaque
)
559 DPRINTF("Enter save live stage %d submitted %d transferred %d\n",
560 stage
, block_mig_state
.submitted
, block_mig_state
.transferred
);
563 blk_mig_cleanup(mon
);
567 if (block_mig_state
.blk_enable
!= 1) {
568 /* no need to migrate storage */
569 qemu_put_be64(f
, BLK_MIG_FLAG_EOS
);
574 init_blk_migration(mon
, f
);
576 /* start track dirty blocks */
577 set_dirty_tracking(1);
582 if (qemu_file_has_error(f
)) {
583 blk_mig_cleanup(mon
);
587 blk_mig_reset_dirty_cursor();
590 /* control the rate of transfer */
591 while ((block_mig_state
.submitted
+
592 block_mig_state
.read_done
) * BLOCK_SIZE
<
593 qemu_file_get_rate_limit(f
)) {
594 if (block_mig_state
.bulk_completed
== 0) {
595 /* first finish the bulk phase */
596 if (blk_mig_save_bulked_block(mon
, f
) == 0) {
597 /* finished saving bulk on all devices */
598 block_mig_state
.bulk_completed
= 1;
601 if (blk_mig_save_dirty_block(mon
, f
, 1) == 0) {
602 /* no more dirty blocks */
610 if (qemu_file_has_error(f
)) {
611 blk_mig_cleanup(mon
);
617 /* we know for sure that save bulk is completed and
618 all async read completed */
619 assert(block_mig_state
.submitted
== 0);
621 while (blk_mig_save_dirty_block(mon
, f
, 0) != 0);
622 blk_mig_cleanup(mon
);
624 /* report completion */
625 qemu_put_be64(f
, (100 << BDRV_SECTOR_BITS
) | BLK_MIG_FLAG_PROGRESS
);
627 if (qemu_file_has_error(f
)) {
631 monitor_printf(mon
, "Block migration completed\n");
634 qemu_put_be64(f
, BLK_MIG_FLAG_EOS
);
636 return ((stage
== 2) && is_stage2_completed());
639 static int block_load(QEMUFile
*f
, void *opaque
, int version_id
)
641 static int banner_printed
;
643 char device_name
[256];
645 BlockDriverState
*bs
, *bs_prev
= NULL
;
647 int64_t total_sectors
= 0;
651 addr
= qemu_get_be64(f
);
653 flags
= addr
& ~BDRV_SECTOR_MASK
;
654 addr
>>= BDRV_SECTOR_BITS
;
656 if (flags
& BLK_MIG_FLAG_DEVICE_BLOCK
) {
658 /* get device name */
659 len
= qemu_get_byte(f
);
660 qemu_get_buffer(f
, (uint8_t *)device_name
, len
);
661 device_name
[len
] = '\0';
663 bs
= bdrv_find(device_name
);
665 fprintf(stderr
, "Error unknown block device %s\n",
672 total_sectors
= bdrv_getlength(bs
) >> BDRV_SECTOR_BITS
;
673 if (total_sectors
<= 0) {
674 error_report("Error getting length of block device %s",
680 if (total_sectors
- addr
< BDRV_SECTORS_PER_DIRTY_CHUNK
) {
681 nr_sectors
= total_sectors
- addr
;
683 nr_sectors
= BDRV_SECTORS_PER_DIRTY_CHUNK
;
686 buf
= qemu_malloc(BLOCK_SIZE
);
688 qemu_get_buffer(f
, buf
, BLOCK_SIZE
);
689 ret
= bdrv_write(bs
, addr
, buf
, nr_sectors
);
695 } else if (flags
& BLK_MIG_FLAG_PROGRESS
) {
696 if (!banner_printed
) {
697 printf("Receiving block device images\n");
700 printf("Completed %d %%%c", (int)addr
,
701 (addr
== 100) ? '\n' : '\r');
703 } else if (!(flags
& BLK_MIG_FLAG_EOS
)) {
704 fprintf(stderr
, "Unknown flags\n");
707 if (qemu_file_has_error(f
)) {
710 } while (!(flags
& BLK_MIG_FLAG_EOS
));
715 static void block_set_params(int blk_enable
, int shared_base
, void *opaque
)
717 block_mig_state
.blk_enable
= blk_enable
;
718 block_mig_state
.shared_base
= shared_base
;
720 /* shared base means that blk_enable = 1 */
721 block_mig_state
.blk_enable
|= shared_base
;
724 void blk_mig_init(void)
726 QSIMPLEQ_INIT(&block_mig_state
.bmds_list
);
727 QSIMPLEQ_INIT(&block_mig_state
.blk_list
);
729 register_savevm_live(NULL
, "block", 0, 1, block_set_params
,
730 block_save_live
, NULL
, block_load
, &block_mig_state
);