virtio-net: stop/start bh when appropriate
[qemu.git] / block-migration.c
blob14753254d6bcdd9e57c10d65d739ab944a9ff94b
1 /*
2 * QEMU live block migration
4 * Copyright IBM, Corp. 2009
6 * Authors:
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"
16 #include "hw/hw.h"
17 #include "qemu-queue.h"
18 #include "qemu-timer.h"
19 #include "monitor.h"
20 #include "block-migration.h"
21 #include "migration.h"
22 #include <assert.h>
24 #define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)
26 #define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
27 #define BLK_MIG_FLAG_EOS 0x02
28 #define BLK_MIG_FLAG_PROGRESS 0x04
30 #define MAX_IS_ALLOCATED_SEARCH 65536
32 //#define DEBUG_BLK_MIGRATION
34 #ifdef DEBUG_BLK_MIGRATION
35 #define DPRINTF(fmt, ...) \
36 do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0)
37 #else
38 #define DPRINTF(fmt, ...) \
39 do { } while (0)
40 #endif
42 typedef struct BlkMigDevState {
43 BlockDriverState *bs;
44 int bulk_completed;
45 int shared_base;
46 int64_t cur_sector;
47 int64_t cur_dirty;
48 int64_t completed_sectors;
49 int64_t total_sectors;
50 int64_t dirty;
51 QSIMPLEQ_ENTRY(BlkMigDevState) entry;
52 unsigned long *aio_bitmap;
53 } BlkMigDevState;
55 typedef struct BlkMigBlock {
56 uint8_t *buf;
57 BlkMigDevState *bmds;
58 int64_t sector;
59 int nr_sectors;
60 struct iovec iov;
61 QEMUIOVector qiov;
62 BlockDriverAIOCB *aiocb;
63 int ret;
64 int64_t time;
65 QSIMPLEQ_ENTRY(BlkMigBlock) entry;
66 } BlkMigBlock;
68 typedef struct BlkMigState {
69 int blk_enable;
70 int shared_base;
71 QSIMPLEQ_HEAD(bmds_list, BlkMigDevState) bmds_list;
72 QSIMPLEQ_HEAD(blk_list, BlkMigBlock) blk_list;
73 int submitted;
74 int read_done;
75 int transferred;
76 int64_t total_sector_sum;
77 int prev_progress;
78 int bulk_completed;
79 long double total_time;
80 int reads;
81 } BlkMigState;
83 static BlkMigState block_mig_state;
85 static void blk_send(QEMUFile *f, BlkMigBlock * blk)
87 int len;
89 /* sector number and flags */
90 qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS)
91 | BLK_MIG_FLAG_DEVICE_BLOCK);
93 /* device name */
94 len = strlen(blk->bmds->bs->device_name);
95 qemu_put_byte(f, len);
96 qemu_put_buffer(f, (uint8_t *)blk->bmds->bs->device_name, len);
98 qemu_put_buffer(f, blk->buf, BLOCK_SIZE);
101 int blk_mig_active(void)
103 return !QSIMPLEQ_EMPTY(&block_mig_state.bmds_list);
106 uint64_t blk_mig_bytes_transferred(void)
108 BlkMigDevState *bmds;
109 uint64_t sum = 0;
111 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
112 sum += bmds->completed_sectors;
114 return sum << BDRV_SECTOR_BITS;
117 uint64_t blk_mig_bytes_remaining(void)
119 return blk_mig_bytes_total() - blk_mig_bytes_transferred();
122 uint64_t blk_mig_bytes_total(void)
124 BlkMigDevState *bmds;
125 uint64_t sum = 0;
127 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
128 sum += bmds->total_sectors;
130 return sum << BDRV_SECTOR_BITS;
133 static inline void add_avg_read_time(int64_t time)
135 block_mig_state.reads++;
136 block_mig_state.total_time += time;
139 static inline long double compute_read_bwidth(void)
141 assert(block_mig_state.total_time != 0);
142 return (block_mig_state.reads * BLOCK_SIZE)/ block_mig_state.total_time;
145 static int bmds_aio_inflight(BlkMigDevState *bmds, int64_t sector)
147 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
149 if ((sector << BDRV_SECTOR_BITS) < bdrv_getlength(bmds->bs)) {
150 return !!(bmds->aio_bitmap[chunk / (sizeof(unsigned long) * 8)] &
151 (1UL << (chunk % (sizeof(unsigned long) * 8))));
152 } else {
153 return 0;
157 static void bmds_set_aio_inflight(BlkMigDevState *bmds, int64_t sector_num,
158 int nb_sectors, int set)
160 int64_t start, end;
161 unsigned long val, idx, bit;
163 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
164 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
166 for (; start <= end; start++) {
167 idx = start / (sizeof(unsigned long) * 8);
168 bit = start % (sizeof(unsigned long) * 8);
169 val = bmds->aio_bitmap[idx];
170 if (set) {
171 val |= 1UL << bit;
172 } else {
173 val &= ~(1UL << bit);
175 bmds->aio_bitmap[idx] = val;
179 static void alloc_aio_bitmap(BlkMigDevState *bmds)
181 BlockDriverState *bs = bmds->bs;
182 int64_t bitmap_size;
184 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) +
185 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
186 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
188 bmds->aio_bitmap = qemu_mallocz(bitmap_size);
191 static void blk_mig_read_cb(void *opaque, int ret)
193 BlkMigBlock *blk = opaque;
195 blk->ret = ret;
197 blk->time = qemu_get_clock_ns(rt_clock) - blk->time;
199 add_avg_read_time(blk->time);
201 QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry);
202 bmds_set_aio_inflight(blk->bmds, blk->sector, blk->nr_sectors, 0);
204 block_mig_state.submitted--;
205 block_mig_state.read_done++;
206 assert(block_mig_state.submitted >= 0);
209 static int mig_save_device_bulk(Monitor *mon, QEMUFile *f,
210 BlkMigDevState *bmds)
212 int64_t total_sectors = bmds->total_sectors;
213 int64_t cur_sector = bmds->cur_sector;
214 BlockDriverState *bs = bmds->bs;
215 BlkMigBlock *blk;
216 int nr_sectors;
218 if (bmds->shared_base) {
219 while (cur_sector < total_sectors &&
220 !bdrv_is_allocated(bs, cur_sector, MAX_IS_ALLOCATED_SEARCH,
221 &nr_sectors)) {
222 cur_sector += nr_sectors;
226 if (cur_sector >= total_sectors) {
227 bmds->cur_sector = bmds->completed_sectors = total_sectors;
228 return 1;
231 bmds->completed_sectors = cur_sector;
233 cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
235 /* we are going to transfer a full block even if it is not allocated */
236 nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
238 if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
239 nr_sectors = total_sectors - cur_sector;
242 blk = qemu_malloc(sizeof(BlkMigBlock));
243 blk->buf = qemu_malloc(BLOCK_SIZE);
244 blk->bmds = bmds;
245 blk->sector = cur_sector;
246 blk->nr_sectors = nr_sectors;
248 blk->iov.iov_base = blk->buf;
249 blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
250 qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
252 blk->time = qemu_get_clock_ns(rt_clock);
254 blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
255 nr_sectors, blk_mig_read_cb, blk);
256 if (!blk->aiocb) {
257 goto error;
259 block_mig_state.submitted++;
261 bdrv_reset_dirty(bs, cur_sector, nr_sectors);
262 bmds->cur_sector = cur_sector + nr_sectors;
264 return (bmds->cur_sector >= total_sectors);
266 error:
267 monitor_printf(mon, "Error reading sector %" PRId64 "\n", cur_sector);
268 qemu_file_set_error(f);
269 qemu_free(blk->buf);
270 qemu_free(blk);
271 return 0;
274 static void set_dirty_tracking(int enable)
276 BlkMigDevState *bmds;
278 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
279 bdrv_set_dirty_tracking(bmds->bs, enable);
283 static void init_blk_migration_it(void *opaque, BlockDriverState *bs)
285 Monitor *mon = opaque;
286 BlkMigDevState *bmds;
287 int64_t sectors;
289 if (!bdrv_is_read_only(bs)) {
290 sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
291 if (sectors <= 0) {
292 return;
295 bmds = qemu_mallocz(sizeof(BlkMigDevState));
296 bmds->bs = bs;
297 bmds->bulk_completed = 0;
298 bmds->total_sectors = sectors;
299 bmds->completed_sectors = 0;
300 bmds->shared_base = block_mig_state.shared_base;
301 alloc_aio_bitmap(bmds);
303 block_mig_state.total_sector_sum += sectors;
305 if (bmds->shared_base) {
306 monitor_printf(mon, "Start migration for %s with shared base "
307 "image\n",
308 bs->device_name);
309 } else {
310 monitor_printf(mon, "Start full migration for %s\n",
311 bs->device_name);
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;
336 int progress;
337 int ret = 0;
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;
346 ret = 1;
347 break;
348 } else {
349 completed_sector_sum += bmds->completed_sectors;
353 progress = completed_sector_sum * 100 / block_mig_state.total_sector_sum;
354 if (progress != block_mig_state.prev_progress) {
355 block_mig_state.prev_progress = progress;
356 qemu_put_be64(f, (progress << BDRV_SECTOR_BITS)
357 | BLK_MIG_FLAG_PROGRESS);
358 monitor_printf(mon, "Completed %d %%\r", progress);
359 monitor_flush(mon);
362 return ret;
365 static void blk_mig_reset_dirty_cursor(void)
367 BlkMigDevState *bmds;
369 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
370 bmds->cur_dirty = 0;
374 static int mig_save_device_dirty(Monitor *mon, QEMUFile *f,
375 BlkMigDevState *bmds, int is_async)
377 BlkMigBlock *blk;
378 int64_t total_sectors = bmds->total_sectors;
379 int64_t sector;
380 int nr_sectors;
382 for (sector = bmds->cur_dirty; sector < bmds->total_sectors;) {
383 if (bmds_aio_inflight(bmds, sector)) {
384 qemu_aio_flush();
386 if (bdrv_get_dirty(bmds->bs, sector)) {
388 if (total_sectors - sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
389 nr_sectors = total_sectors - sector;
390 } else {
391 nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
393 blk = qemu_malloc(sizeof(BlkMigBlock));
394 blk->buf = qemu_malloc(BLOCK_SIZE);
395 blk->bmds = bmds;
396 blk->sector = sector;
397 blk->nr_sectors = nr_sectors;
399 if (is_async) {
400 blk->iov.iov_base = blk->buf;
401 blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
402 qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
404 blk->time = qemu_get_clock_ns(rt_clock);
406 blk->aiocb = bdrv_aio_readv(bmds->bs, sector, &blk->qiov,
407 nr_sectors, blk_mig_read_cb, blk);
408 if (!blk->aiocb) {
409 goto error;
411 block_mig_state.submitted++;
412 bmds_set_aio_inflight(bmds, sector, nr_sectors, 1);
413 } else {
414 if (bdrv_read(bmds->bs, sector, blk->buf,
415 nr_sectors) < 0) {
416 goto error;
418 blk_send(f, blk);
420 qemu_free(blk->buf);
421 qemu_free(blk);
424 bdrv_reset_dirty(bmds->bs, sector, nr_sectors);
425 break;
427 sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
428 bmds->cur_dirty = sector;
431 return (bmds->cur_dirty >= bmds->total_sectors);
433 error:
434 monitor_printf(mon, "Error reading sector %" PRId64 "\n", sector);
435 qemu_file_set_error(f);
436 qemu_free(blk->buf);
437 qemu_free(blk);
438 return 0;
441 static int blk_mig_save_dirty_block(Monitor *mon, QEMUFile *f, int is_async)
443 BlkMigDevState *bmds;
444 int ret = 0;
446 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
447 if (mig_save_device_dirty(mon, f, bmds, is_async) == 0) {
448 ret = 1;
449 break;
453 return ret;
456 static void flush_blks(QEMUFile* f)
458 BlkMigBlock *blk;
460 DPRINTF("%s Enter submitted %d read_done %d transferred %d\n",
461 __FUNCTION__, block_mig_state.submitted, block_mig_state.read_done,
462 block_mig_state.transferred);
464 while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
465 if (qemu_file_rate_limit(f)) {
466 break;
468 if (blk->ret < 0) {
469 qemu_file_set_error(f);
470 break;
472 blk_send(f, blk);
474 QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
475 qemu_free(blk->buf);
476 qemu_free(blk);
478 block_mig_state.read_done--;
479 block_mig_state.transferred++;
480 assert(block_mig_state.read_done >= 0);
483 DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__,
484 block_mig_state.submitted, block_mig_state.read_done,
485 block_mig_state.transferred);
488 static int64_t get_remaining_dirty(void)
490 BlkMigDevState *bmds;
491 int64_t dirty = 0;
493 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
494 dirty += bdrv_get_dirty_count(bmds->bs);
497 return dirty * BLOCK_SIZE;
500 static int is_stage2_completed(void)
502 int64_t remaining_dirty;
503 long double bwidth;
505 if (block_mig_state.bulk_completed == 1) {
507 remaining_dirty = get_remaining_dirty();
508 if (remaining_dirty == 0) {
509 return 1;
512 bwidth = compute_read_bwidth();
514 if ((remaining_dirty / bwidth) <=
515 migrate_max_downtime()) {
516 /* finish stage2 because we think that we can finish remaing work
517 below max_downtime */
519 return 1;
523 return 0;
526 static void blk_mig_cleanup(Monitor *mon)
528 BlkMigDevState *bmds;
529 BlkMigBlock *blk;
531 while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) {
532 QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);
533 qemu_free(bmds->aio_bitmap);
534 qemu_free(bmds);
537 while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
538 QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
539 qemu_free(blk->buf);
540 qemu_free(blk);
543 set_dirty_tracking(0);
545 monitor_printf(mon, "\n");
548 static int block_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
550 DPRINTF("Enter save live stage %d submitted %d transferred %d\n",
551 stage, block_mig_state.submitted, block_mig_state.transferred);
553 if (stage < 0) {
554 blk_mig_cleanup(mon);
555 return 0;
558 if (block_mig_state.blk_enable != 1) {
559 /* no need to migrate storage */
560 qemu_put_be64(f, BLK_MIG_FLAG_EOS);
561 return 1;
564 if (stage == 1) {
565 init_blk_migration(mon, f);
567 /* start track dirty blocks */
568 set_dirty_tracking(1);
571 flush_blks(f);
573 if (qemu_file_has_error(f)) {
574 blk_mig_cleanup(mon);
575 return 0;
578 blk_mig_reset_dirty_cursor();
580 if (stage == 2) {
581 /* control the rate of transfer */
582 while ((block_mig_state.submitted +
583 block_mig_state.read_done) * BLOCK_SIZE <
584 qemu_file_get_rate_limit(f)) {
585 if (block_mig_state.bulk_completed == 0) {
586 /* first finish the bulk phase */
587 if (blk_mig_save_bulked_block(mon, f) == 0) {
588 /* finished saving bulk on all devices */
589 block_mig_state.bulk_completed = 1;
591 } else {
592 if (blk_mig_save_dirty_block(mon, f, 1) == 0) {
593 /* no more dirty blocks */
594 break;
599 flush_blks(f);
601 if (qemu_file_has_error(f)) {
602 blk_mig_cleanup(mon);
603 return 0;
607 if (stage == 3) {
608 /* we know for sure that save bulk is completed and
609 all async read completed */
610 assert(block_mig_state.submitted == 0);
612 while (blk_mig_save_dirty_block(mon, f, 0) != 0);
613 blk_mig_cleanup(mon);
615 /* report completion */
616 qemu_put_be64(f, (100 << BDRV_SECTOR_BITS) | BLK_MIG_FLAG_PROGRESS);
618 if (qemu_file_has_error(f)) {
619 return 0;
622 monitor_printf(mon, "Block migration completed\n");
625 qemu_put_be64(f, BLK_MIG_FLAG_EOS);
627 return ((stage == 2) && is_stage2_completed());
630 static int block_load(QEMUFile *f, void *opaque, int version_id)
632 static int banner_printed;
633 int len, flags;
634 char device_name[256];
635 int64_t addr;
636 BlockDriverState *bs;
637 uint8_t *buf;
639 do {
640 addr = qemu_get_be64(f);
642 flags = addr & ~BDRV_SECTOR_MASK;
643 addr >>= BDRV_SECTOR_BITS;
645 if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
646 int ret;
647 /* get device name */
648 len = qemu_get_byte(f);
649 qemu_get_buffer(f, (uint8_t *)device_name, len);
650 device_name[len] = '\0';
652 bs = bdrv_find(device_name);
653 if (!bs) {
654 fprintf(stderr, "Error unknown block device %s\n",
655 device_name);
656 return -EINVAL;
659 buf = qemu_malloc(BLOCK_SIZE);
661 qemu_get_buffer(f, buf, BLOCK_SIZE);
662 ret = bdrv_write(bs, addr, buf, BDRV_SECTORS_PER_DIRTY_CHUNK);
664 qemu_free(buf);
665 if (ret < 0) {
666 return ret;
668 } else if (flags & BLK_MIG_FLAG_PROGRESS) {
669 if (!banner_printed) {
670 printf("Receiving block device images\n");
671 banner_printed = 1;
673 printf("Completed %d %%%c", (int)addr,
674 (addr == 100) ? '\n' : '\r');
675 fflush(stdout);
676 } else if (!(flags & BLK_MIG_FLAG_EOS)) {
677 fprintf(stderr, "Unknown flags\n");
678 return -EINVAL;
680 if (qemu_file_has_error(f)) {
681 return -EIO;
683 } while (!(flags & BLK_MIG_FLAG_EOS));
685 return 0;
688 static void block_set_params(int blk_enable, int shared_base, void *opaque)
690 block_mig_state.blk_enable = blk_enable;
691 block_mig_state.shared_base = shared_base;
693 /* shared base means that blk_enable = 1 */
694 block_mig_state.blk_enable |= shared_base;
697 void blk_mig_init(void)
699 QSIMPLEQ_INIT(&block_mig_state.bmds_list);
700 QSIMPLEQ_INIT(&block_mig_state.blk_list);
702 register_savevm_live(NULL, "block", 0, 1, block_set_params,
703 block_save_live, NULL, block_load, &block_mig_state);