[qemu.git] / block-migration.c

/*
 * QEMU live block migration
 *
 * Copyright IBM, Corp. 2009
 *
 * Authors:
 *  Liran Schour   <lirans@il.ibm.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
 */

#include "qemu-common.h"
#include "block_int.h"
#include "hw/hw.h"
#include "qemu-queue.h"
#include "monitor.h"
#include "block-migration.h"
#include <assert.h>

#define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)

#define BLK_MIG_FLAG_DEVICE_BLOCK       0x01
#define BLK_MIG_FLAG_EOS                0x02
#define BLK_MIG_FLAG_PROGRESS           0x04

#define MAX_IS_ALLOCATED_SEARCH 65536
#define MAX_BLOCKS_READ 10000
#define BLOCKS_READ_CHANGE 100
#define INITIAL_BLOCKS_READ 100

//#define DEBUG_BLK_MIGRATION

#ifdef DEBUG_BLK_MIGRATION
#define DPRINTF(fmt, ...) \
    do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0)
#else
#define DPRINTF(fmt, ...) \
    do { } while (0)
#endif

typedef struct BlkMigDevState {
    BlockDriverState *bs;
    int bulk_completed;
    int shared_base;
    int64_t cur_sector;
    int64_t completed_sectors;
    int64_t total_sectors;
    int64_t dirty;
    QSIMPLEQ_ENTRY(BlkMigDevState) entry;
} BlkMigDevState;

typedef struct BlkMigBlock {
    uint8_t *buf;
    BlkMigDevState *bmds;
    int64_t sector;
    struct iovec iov;
    QEMUIOVector qiov;
    BlockDriverAIOCB *aiocb;
    int ret;
    QSIMPLEQ_ENTRY(BlkMigBlock) entry;
} BlkMigBlock;

typedef struct BlkMigState {
    int blk_enable;
    int shared_base;
    QSIMPLEQ_HEAD(bmds_list, BlkMigDevState) bmds_list;
    QSIMPLEQ_HEAD(blk_list, BlkMigBlock) blk_list;
    int submitted;
    int read_done;
    int transferred;
    int64_t total_sector_sum;
    int prev_progress;
} BlkMigState;

static BlkMigState block_mig_state;

static void blk_send(QEMUFile *f, BlkMigBlock * blk)
{
    int len;

    /* sector number and flags */
    qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS)
                     | BLK_MIG_FLAG_DEVICE_BLOCK);

    /* device name */
    len = strlen(blk->bmds->bs->device_name);
    qemu_put_byte(f, len);
    qemu_put_buffer(f, (uint8_t *)blk->bmds->bs->device_name, len);

    qemu_put_buffer(f, blk->buf, BLOCK_SIZE);
}

int blk_mig_active(void)
{
    return !QSIMPLEQ_EMPTY(&block_mig_state.bmds_list);
}

uint64_t blk_mig_bytes_transferred(void)
{
    BlkMigDevState *bmds;
    uint64_t sum = 0;

    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
        sum += bmds->completed_sectors;
    }
    return sum << BDRV_SECTOR_BITS;
}

uint64_t blk_mig_bytes_remaining(void)
{
    return blk_mig_bytes_total() - blk_mig_bytes_transferred();
}

uint64_t blk_mig_bytes_total(void)
{
    BlkMigDevState *bmds;
    uint64_t sum = 0;

    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
        sum += bmds->total_sectors;
    }
    return sum << BDRV_SECTOR_BITS;
}

static void blk_mig_read_cb(void *opaque, int ret)
{
    BlkMigBlock *blk = opaque;

    blk->ret = ret;

    QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry);

    block_mig_state.submitted--;
    block_mig_state.read_done++;
    assert(block_mig_state.submitted >= 0);
}

static int mig_save_device_bulk(Monitor *mon, QEMUFile *f,
                                BlkMigDevState *bmds, int is_async)
{
    int64_t total_sectors = bmds->total_sectors;
    int64_t cur_sector = bmds->cur_sector;
    BlockDriverState *bs = bmds->bs;
    BlkMigBlock *blk;
    int nr_sectors;

    if (bmds->shared_base) {
        while (cur_sector < total_sectors &&
               !bdrv_is_allocated(bs, cur_sector, MAX_IS_ALLOCATED_SEARCH,
                                  &nr_sectors)) {
            cur_sector += nr_sectors;
        }
    }

    if (cur_sector >= total_sectors) {
        bmds->cur_sector = bmds->completed_sectors = total_sectors;
        return 1;
    }

    bmds->completed_sectors = cur_sector;

    cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);

    /* we are going to transfer a full block even if it is not allocated */
    nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;

    if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
        nr_sectors = total_sectors - cur_sector;
    }

    blk = qemu_malloc(sizeof(BlkMigBlock));
    blk->buf = qemu_malloc(BLOCK_SIZE);
    blk->bmds = bmds;
    blk->sector = cur_sector;

    if (is_async) {
        blk->iov.iov_base = blk->buf;
        blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
        qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);

        blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
                                    nr_sectors, blk_mig_read_cb, blk);
        if (!blk->aiocb) {
            goto error;
        }
        block_mig_state.submitted++;
    } else {
        if (bdrv_read(bs, cur_sector, blk->buf, nr_sectors) < 0) {
            goto error;
        }
        blk_send(f, blk);

        qemu_free(blk->buf);
        qemu_free(blk);
    }

    bdrv_reset_dirty(bs, cur_sector, nr_sectors);
    bmds->cur_sector = cur_sector + nr_sectors;

    return (bmds->cur_sector >= total_sectors);

error:
    monitor_printf(mon, "Error reading sector %" PRId64 "\n", cur_sector);
    qemu_file_set_error(f);
    qemu_free(blk->buf);
    qemu_free(blk);
    return 0;
}

static void set_dirty_tracking(int enable)
{
    BlkMigDevState *bmds;

    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
        bdrv_set_dirty_tracking(bmds->bs, enable);
    }
}

static void init_blk_migration(Monitor *mon, QEMUFile *f)
{
    BlkMigDevState *bmds;
    BlockDriverState *bs;
    int64_t sectors;

    block_mig_state.submitted = 0;
    block_mig_state.read_done = 0;
    block_mig_state.transferred = 0;
    block_mig_state.total_sector_sum = 0;
    block_mig_state.prev_progress = -1;

    for (bs = bdrv_first; bs != NULL; bs = bs->next) {
        if (bs->type == BDRV_TYPE_HD) {
            sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
            if (sectors == 0) {
                continue;
            }

            bmds = qemu_mallocz(sizeof(BlkMigDevState));
            bmds->bs = bs;
            bmds->bulk_completed = 0;
            bmds->total_sectors = sectors;
            bmds->completed_sectors = 0;
            bmds->shared_base = block_mig_state.shared_base;

            block_mig_state.total_sector_sum += sectors;

            if (bmds->shared_base) {
                monitor_printf(mon, "Start migration for %s with shared base "
                                    "image\n",
                               bs->device_name);
            } else {
                monitor_printf(mon, "Start full migration for %s\n",
                               bs->device_name);
            }

            QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry);
        }
    }
}

static int blk_mig_save_bulked_block(Monitor *mon, QEMUFile *f, int is_async)
{
    int64_t completed_sector_sum = 0;
    BlkMigDevState *bmds;
    int progress;
    int ret = 0;

    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
        if (bmds->bulk_completed == 0) {
            if (mig_save_device_bulk(mon, f, bmds, is_async) == 1) {
                /* completed bulk section for this device */
                bmds->bulk_completed = 1;
            }
            completed_sector_sum += bmds->completed_sectors;
            ret = 1;
            break;
        } else {
            completed_sector_sum += bmds->completed_sectors;
        }
    }

    progress = completed_sector_sum * 100 / block_mig_state.total_sector_sum;
    if (progress != block_mig_state.prev_progress) {
        block_mig_state.prev_progress = progress;
        qemu_put_be64(f, (progress << BDRV_SECTOR_BITS)
                         | BLK_MIG_FLAG_PROGRESS);
        monitor_printf(mon, "Completed %d %%\r", progress);
        monitor_flush(mon);
    }

    return ret;
}

#define MAX_NUM_BLOCKS 4

static void blk_mig_save_dirty_blocks(Monitor *mon, QEMUFile *f)
{
    BlkMigDevState *bmds;
    BlkMigBlock blk;
    int64_t sector;

    blk.buf = qemu_malloc(BLOCK_SIZE);

    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
        for (sector = 0; sector < bmds->cur_sector;) {
            if (bdrv_get_dirty(bmds->bs, sector)) {
                if (bdrv_read(bmds->bs, sector, blk.buf,
                              BDRV_SECTORS_PER_DIRTY_CHUNK) < 0) {
                    monitor_printf(mon, "Error reading sector %" PRId64 "\n",
                                   sector);
                    qemu_file_set_error(f);
                    qemu_free(blk.buf);
                    return;
                }
                blk.bmds = bmds;
                blk.sector = sector;
                blk_send(f, &blk);

                bdrv_reset_dirty(bmds->bs, sector,
                                 BDRV_SECTORS_PER_DIRTY_CHUNK);
            }
            sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
        }
    }

    qemu_free(blk.buf);
}

static void flush_blks(QEMUFile* f)
{
    BlkMigBlock *blk;

    DPRINTF("%s Enter submitted %d read_done %d transferred %d\n",
            __FUNCTION__, block_mig_state.submitted, block_mig_state.read_done,
            block_mig_state.transferred);

    while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
        if (qemu_file_rate_limit(f)) {
            break;
        }
        if (blk->ret < 0) {
            qemu_file_set_error(f);
            break;
        }
        blk_send(f, blk);

        QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
        qemu_free(blk->buf);
        qemu_free(blk);

        block_mig_state.read_done--;
        block_mig_state.transferred++;
        assert(block_mig_state.read_done >= 0);
    }

    DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__,
            block_mig_state.submitted, block_mig_state.read_done,
            block_mig_state.transferred);
}

static int is_stage2_completed(void)
{
    BlkMigDevState *bmds;

    if (block_mig_state.submitted > 0) {
        return 0;
    }

    QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
        if (bmds->bulk_completed == 0) {
            return 0;
        }
    }

    return 1;
}

static void blk_mig_cleanup(Monitor *mon)
{
    BlkMigDevState *bmds;
    BlkMigBlock *blk;

    while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) {
        QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);
        qemu_free(bmds);
    }

    while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
        QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
        qemu_free(blk->buf);
        qemu_free(blk);
    }

    set_dirty_tracking(0);

    monitor_printf(mon, "\n");
}

static int block_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
{
    DPRINTF("Enter save live stage %d submitted %d transferred %d\n",
            stage, block_mig_state.submitted, block_mig_state.transferred);

    if (stage < 0) {
        blk_mig_cleanup(mon);
        return 0;
    }

    if (block_mig_state.blk_enable != 1) {
        /* no need to migrate storage */
        qemu_put_be64(f, BLK_MIG_FLAG_EOS);
        return 1;
    }

    if (stage == 1) {
        init_blk_migration(mon, f);

        /* start track dirty blocks */
        set_dirty_tracking(1);
    }

    flush_blks(f);

    if (qemu_file_has_error(f)) {
        blk_mig_cleanup(mon);
        return 0;
    }

    /* control the rate of transfer */
    while ((block_mig_state.submitted +
            block_mig_state.read_done) * BLOCK_SIZE <
           qemu_file_get_rate_limit(f)) {
        if (blk_mig_save_bulked_block(mon, f, 1) == 0) {
            /* no more bulk blocks for now */
            break;
        }
    }

    flush_blks(f);

    if (qemu_file_has_error(f)) {
        blk_mig_cleanup(mon);
        return 0;
    }

    if (stage == 3) {
        while (blk_mig_save_bulked_block(mon, f, 0) != 0) {
            /* empty */
        }

        blk_mig_save_dirty_blocks(mon, f);
        blk_mig_cleanup(mon);

        /* report completion */
        qemu_put_be64(f, (100 << BDRV_SECTOR_BITS) | BLK_MIG_FLAG_PROGRESS);

        if (qemu_file_has_error(f)) {
            return 0;
        }

        monitor_printf(mon, "Block migration completed\n");
    }

    qemu_put_be64(f, BLK_MIG_FLAG_EOS);

    return ((stage == 2) && is_stage2_completed());
}

static int block_load(QEMUFile *f, void *opaque, int version_id)
{
    static int banner_printed;
    int len, flags;
    char device_name[256];
    int64_t addr;
    BlockDriverState *bs;
    uint8_t *buf;

    do {
        addr = qemu_get_be64(f);

        flags = addr & ~BDRV_SECTOR_MASK;
        addr >>= BDRV_SECTOR_BITS;

        if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
            /* get device name */
            len = qemu_get_byte(f);
            qemu_get_buffer(f, (uint8_t *)device_name, len);
            device_name[len] = '\0';

            bs = bdrv_find(device_name);
            if (!bs) {
                fprintf(stderr, "Error unknown block device %s\n",
                        device_name);
                return -EINVAL;
            }

            buf = qemu_malloc(BLOCK_SIZE);

            qemu_get_buffer(f, buf, BLOCK_SIZE);
            bdrv_write(bs, addr, buf, BDRV_SECTORS_PER_DIRTY_CHUNK);

            qemu_free(buf);
        } else if (flags & BLK_MIG_FLAG_PROGRESS) {
            if (!banner_printed) {
                printf("Receiving block device images\n");
                banner_printed = 1;
            }
            printf("Completed %d %%%c", (int)addr,
                   (addr == 100) ? '\n' : '\r');
            fflush(stdout);
        } else if (!(flags & BLK_MIG_FLAG_EOS)) {
            fprintf(stderr, "Unknown flags\n");
            return -EINVAL;
        }
        if (qemu_file_has_error(f)) {
            return -EIO;
        }
    } while (!(flags & BLK_MIG_FLAG_EOS));

    return 0;
}

static void block_set_params(int blk_enable, int shared_base, void *opaque)
{
    block_mig_state.blk_enable = blk_enable;
    block_mig_state.shared_base = shared_base;

    /* shared base means that blk_enable = 1 */
    block_mig_state.blk_enable |= shared_base;
}

void blk_mig_init(void)
{
    QSIMPLEQ_INIT(&block_mig_state.bmds_list);
    QSIMPLEQ_INIT(&block_mig_state.blk_list);

    register_savevm_live("block", 0, 1, block_set_params, block_save_live,
                         NULL, block_load, &block_mig_state);
}
Commit	Line	Data
c163b5ca	1	/*
	2	* QEMU live block migration
	3	*
	4	* Copyright IBM, Corp. 2009
	5	*
	6	* Authors:
	7	* Liran Schour <lirans@il.ibm.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2. See
	10	* the COPYING file in the top-level directory.
	11	*
	12	*/
	13
	14	#include "qemu-common.h"
	15	#include "block_int.h"
	16	#include "hw/hw.h"
5e5328be	17	#include "qemu-queue.h"
7184049e	18	#include "monitor.h"
c163b5ca	19	#include "block-migration.h"
c163b5ca	20	#include <assert.h>
c163b5ca	21
6ea44308	22	#define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)
c163b5ca	23
	24	#define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
	25	#define BLK_MIG_FLAG_EOS 0x02
01e61e2d	26	#define BLK_MIG_FLAG_PROGRESS 0x04
c163b5ca	27
	28	#define MAX_IS_ALLOCATED_SEARCH 65536
	29	#define MAX_BLOCKS_READ 10000
	30	#define BLOCKS_READ_CHANGE 100
	31	#define INITIAL_BLOCKS_READ 100
	32
	33	//#define DEBUG_BLK_MIGRATION
	34
	35	#ifdef DEBUG_BLK_MIGRATION
d0f2c4c6	36	#define DPRINTF(fmt, ...) \
c163b5ca	37	do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0)
c163b5ca	38	#else
d0f2c4c6	39	#define DPRINTF(fmt, ...) \
c163b5ca	40	do { } while (0)
	41	#endif
	42
a55eb92c JK	43	typedef struct BlkMigDevState {
	44	BlockDriverState *bs;
	45	int bulk_completed;
	46	int shared_base;
a55eb92c	47	int64_t cur_sector;
82801d8f	48	int64_t completed_sectors;
a55eb92c JK	49	int64_t total_sectors;
a55eb92c JK	50	int64_t dirty;
5e5328be	51	QSIMPLEQ_ENTRY(BlkMigDevState) entry;
a55eb92c JK	52	} BlkMigDevState;
a55eb92c JK	53
c163b5ca	54	typedef struct BlkMigBlock {
	55	uint8_t *buf;
	56	BlkMigDevState *bmds;
	57	int64_t sector;
	58	struct iovec iov;
	59	QEMUIOVector qiov;
	60	BlockDriverAIOCB *aiocb;
	61	int ret;
5e5328be	62	QSIMPLEQ_ENTRY(BlkMigBlock) entry;
c163b5ca	63	} BlkMigBlock;
	64
	65	typedef struct BlkMigState {
c163b5ca	66	int blk_enable;
c163b5ca	67	int shared_base;
5e5328be JK	68	QSIMPLEQ_HEAD(bmds_list, BlkMigDevState) bmds_list;
5e5328be JK	69	QSIMPLEQ_HEAD(blk_list, BlkMigBlock) blk_list;
c163b5ca	70	int submitted;
	71	int read_done;
	72	int transferred;
82801d8f	73	int64_t total_sector_sum;
01e61e2d	74	int prev_progress;
c163b5ca	75	} BlkMigState;
c163b5ca	76
d11ecd3d	77	static BlkMigState block_mig_state;
c163b5ca	78
13f0b67f JK	79	static void blk_send(QEMUFile f, BlkMigBlock blk)
	80	{
	81	int len;
	82
	83	/* sector number and flags */
	84	qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS)
	85	\| BLK_MIG_FLAG_DEVICE_BLOCK);
	86
	87	/* device name */
	88	len = strlen(blk->bmds->bs->device_name);
	89	qemu_put_byte(f, len);
	90	qemu_put_buffer(f, (uint8_t *)blk->bmds->bs->device_name, len);
	91
	92	qemu_put_buffer(f, blk->buf, BLOCK_SIZE);
	93	}
	94
25f23643 JK	95	int blk_mig_active(void)
	96	{
	97	return !QSIMPLEQ_EMPTY(&block_mig_state.bmds_list);
	98	}
	99
	100	uint64_t blk_mig_bytes_transferred(void)
	101	{
	102	BlkMigDevState *bmds;
	103	uint64_t sum = 0;
	104
	105	QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
	106	sum += bmds->completed_sectors;
	107	}
	108	return sum << BDRV_SECTOR_BITS;
	109	}
	110
	111	uint64_t blk_mig_bytes_remaining(void)
	112	{
	113	return blk_mig_bytes_total() - blk_mig_bytes_transferred();
	114	}
	115
	116	uint64_t blk_mig_bytes_total(void)
	117	{
	118	BlkMigDevState *bmds;
	119	uint64_t sum = 0;
	120
	121	QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
	122	sum += bmds->total_sectors;
	123	}
	124	return sum << BDRV_SECTOR_BITS;
	125	}
	126
c163b5ca	127	static void blk_mig_read_cb(void *opaque, int ret)
	128	{
	129	BlkMigBlock *blk = opaque;
a55eb92c	130
c163b5ca	131	blk->ret = ret;
a55eb92c	132
5e5328be	133	QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry);
a55eb92c	134
d11ecd3d JK	135	block_mig_state.submitted--;
	136	block_mig_state.read_done++;
	137	assert(block_mig_state.submitted >= 0);
c163b5ca	138	}
c163b5ca	139
7184049e JK	140	static int mig_save_device_bulk(Monitor mon, QEMUFile f,
7184049e JK	141	BlkMigDevState *bmds, int is_async)
a55eb92c	142	{
57cce12d JK	143	int64_t total_sectors = bmds->total_sectors;
	144	int64_t cur_sector = bmds->cur_sector;
	145	BlockDriverState *bs = bmds->bs;
c163b5ca	146	BlkMigBlock *blk;
13f0b67f	147	int nr_sectors;
a55eb92c	148
57cce12d	149	if (bmds->shared_base) {
b1d10856	150	while (cur_sector < total_sectors &&
57cce12d JK	151	!bdrv_is_allocated(bs, cur_sector, MAX_IS_ALLOCATED_SEARCH,
57cce12d JK	152	&nr_sectors)) {
c163b5ca	153	cur_sector += nr_sectors;
	154	}
	155	}
a55eb92c JK	156
a55eb92c JK	157	if (cur_sector >= total_sectors) {
82801d8f	158	bmds->cur_sector = bmds->completed_sectors = total_sectors;
c163b5ca	159	return 1;
c163b5ca	160	}
a55eb92c	161
82801d8f	162	bmds->completed_sectors = cur_sector;
a55eb92c	163
57cce12d JK	164	cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
57cce12d JK	165
6ea44308 JK	166	/* we are going to transfer a full block even if it is not allocated */
6ea44308 JK	167	nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
c163b5ca	168
6ea44308	169	if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
57cce12d	170	nr_sectors = total_sectors - cur_sector;
c163b5ca	171	}
a55eb92c	172
13f0b67f JK	173	blk = qemu_malloc(sizeof(BlkMigBlock));
	174	blk->buf = qemu_malloc(BLOCK_SIZE);
	175	blk->bmds = bmds;
	176	blk->sector = cur_sector;
a55eb92c	177
13f0b67f	178	if (is_async) {
57cce12d JK	179	blk->iov.iov_base = blk->buf;
	180	blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
	181	qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
a55eb92c	182
57cce12d JK	183	blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
57cce12d JK	184	nr_sectors, blk_mig_read_cb, blk);
57cce12d	185	if (!blk->aiocb) {
4b640365	186	goto error;
57cce12d	187	}
57cce12d	188	block_mig_state.submitted++;
57cce12d	189	} else {
13f0b67f	190	if (bdrv_read(bs, cur_sector, blk->buf, nr_sectors) < 0) {
4b640365	191	goto error;
c163b5ca	192	}
13f0b67f	193	blk_send(f, blk);
a55eb92c	194
13f0b67f JK	195	qemu_free(blk->buf);
13f0b67f JK	196	qemu_free(blk);
c163b5ca	197	}
c163b5ca	198
13f0b67f JK	199	bdrv_reset_dirty(bs, cur_sector, nr_sectors);
13f0b67f JK	200	bmds->cur_sector = cur_sector + nr_sectors;
a55eb92c	201
13f0b67f	202	return (bmds->cur_sector >= total_sectors);
4b640365 JK	203
4b640365 JK	204	error:
7184049e	205	monitor_printf(mon, "Error reading sector %" PRId64 "\n", cur_sector);
4b640365 JK	206	qemu_file_set_error(f);
	207	qemu_free(blk->buf);
	208	qemu_free(blk);
	209	return 0;
c163b5ca	210	}
c163b5ca	211
c163b5ca	212	static void set_dirty_tracking(int enable)
	213	{
	214	BlkMigDevState *bmds;
5e5328be JK	215
5e5328be JK	216	QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
a55eb92c	217	bdrv_set_dirty_tracking(bmds->bs, enable);
c163b5ca	218	}
c163b5ca	219	}
c163b5ca	220
7184049e	221	static void init_blk_migration(Monitor mon, QEMUFile f)
c163b5ca	222	{
5e5328be	223	BlkMigDevState *bmds;
c163b5ca	224	BlockDriverState *bs;
792773b2	225	int64_t sectors;
a55eb92c	226
69d63a97 JK	227	block_mig_state.submitted = 0;
	228	block_mig_state.read_done = 0;
	229	block_mig_state.transferred = 0;
82801d8f	230	block_mig_state.total_sector_sum = 0;
01e61e2d	231	block_mig_state.prev_progress = -1;
69d63a97	232
c163b5ca	233	for (bs = bdrv_first; bs != NULL; bs = bs->next) {
a55eb92c	234	if (bs->type == BDRV_TYPE_HD) {
792773b2 JK	235	sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
	236	if (sectors == 0) {
	237	continue;
	238	}
	239
c163b5ca	240	bmds = qemu_mallocz(sizeof(BlkMigDevState));
	241	bmds->bs = bs;
	242	bmds->bulk_completed = 0;
792773b2	243	bmds->total_sectors = sectors;
82801d8f	244	bmds->completed_sectors = 0;
d11ecd3d	245	bmds->shared_base = block_mig_state.shared_base;
a55eb92c	246
792773b2	247	block_mig_state.total_sector_sum += sectors;
82801d8f	248
a55eb92c	249	if (bmds->shared_base) {
7184049e JK	250	monitor_printf(mon, "Start migration for %s with shared base "
	251	"image\n",
	252	bs->device_name);
c163b5ca	253	} else {
7184049e JK	254	monitor_printf(mon, "Start full migration for %s\n",
7184049e JK	255	bs->device_name);
c163b5ca	256	}
a55eb92c	257
5e5328be	258	QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry);
c163b5ca	259	}
a55eb92c	260	}
c163b5ca	261	}
c163b5ca	262
7184049e	263	static int blk_mig_save_bulked_block(Monitor mon, QEMUFile f, int is_async)
c163b5ca	264	{
82801d8f	265	int64_t completed_sector_sum = 0;
c163b5ca	266	BlkMigDevState *bmds;
01e61e2d	267	int progress;
82801d8f	268	int ret = 0;
c163b5ca	269
5e5328be	270	QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
a55eb92c	271	if (bmds->bulk_completed == 0) {
7184049e	272	if (mig_save_device_bulk(mon, f, bmds, is_async) == 1) {
57cce12d JK	273	/* completed bulk section for this device */
57cce12d JK	274	bmds->bulk_completed = 1;
c163b5ca	275	}
82801d8f JK	276	completed_sector_sum += bmds->completed_sectors;
	277	ret = 1;
	278	break;
	279	} else {
	280	completed_sector_sum += bmds->completed_sectors;
c163b5ca	281	}
c163b5ca	282	}
a55eb92c	283
01e61e2d JK	284	progress = completed_sector_sum * 100 / block_mig_state.total_sector_sum;
	285	if (progress != block_mig_state.prev_progress) {
	286	block_mig_state.prev_progress = progress;
	287	qemu_put_be64(f, (progress << BDRV_SECTOR_BITS)
	288	\| BLK_MIG_FLAG_PROGRESS);
	289	monitor_printf(mon, "Completed %d %%\r", progress);
7184049e	290	monitor_flush(mon);
82801d8f JK	291	}
	292
	293	return ret;
c163b5ca	294	}
	295
	296	#define MAX_NUM_BLOCKS 4
	297
7184049e	298	static void blk_mig_save_dirty_blocks(Monitor mon, QEMUFile f)
c163b5ca	299	{
c163b5ca	300	BlkMigDevState *bmds;
13f0b67f	301	BlkMigBlock blk;
c163b5ca	302	int64_t sector;
a55eb92c	303
13f0b67f	304	blk.buf = qemu_malloc(BLOCK_SIZE);
575a58d7	305
5e5328be	306	QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
a55eb92c JK	307	for (sector = 0; sector < bmds->cur_sector;) {
a55eb92c JK	308	if (bdrv_get_dirty(bmds->bs, sector)) {
13f0b67f	309	if (bdrv_read(bmds->bs, sector, blk.buf,
6ea44308	310	BDRV_SECTORS_PER_DIRTY_CHUNK) < 0) {
7184049e JK	311	monitor_printf(mon, "Error reading sector %" PRId64 "\n",
7184049e JK	312	sector);
4b640365 JK	313	qemu_file_set_error(f);
	314	qemu_free(blk.buf);
	315	return;
c163b5ca	316	}
13f0b67f JK	317	blk.bmds = bmds;
	318	blk.sector = sector;
	319	blk_send(f, &blk);
a55eb92c JK	320
a55eb92c JK	321	bdrv_reset_dirty(bmds->bs, sector,
6ea44308	322	BDRV_SECTORS_PER_DIRTY_CHUNK);
a55eb92c	323	}
6ea44308	324	sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
c163b5ca	325	}
c163b5ca	326	}
575a58d7	327
13f0b67f	328	qemu_free(blk.buf);
c163b5ca	329	}
	330
	331	static void flush_blks(QEMUFile* f)
	332	{
5e5328be	333	BlkMigBlock *blk;
a55eb92c	334
d0f2c4c6	335	DPRINTF("%s Enter submitted %d read_done %d transferred %d\n",
d11ecd3d JK	336	__FUNCTION__, block_mig_state.submitted, block_mig_state.read_done,
d11ecd3d JK	337	block_mig_state.transferred);
a55eb92c	338
5e5328be JK	339	while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
	340	if (qemu_file_rate_limit(f)) {
	341	break;
	342	}
4b640365 JK	343	if (blk->ret < 0) {
	344	qemu_file_set_error(f);
	345	break;
	346	}
13f0b67f	347	blk_send(f, blk);
a55eb92c	348
5e5328be	349	QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
c163b5ca	350	qemu_free(blk->buf);
c163b5ca	351	qemu_free(blk);
a55eb92c	352
d11ecd3d JK	353	block_mig_state.read_done--;
	354	block_mig_state.transferred++;
	355	assert(block_mig_state.read_done >= 0);
c163b5ca	356	}
c163b5ca	357
d0f2c4c6	358	DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__,
d11ecd3d JK	359	block_mig_state.submitted, block_mig_state.read_done,
d11ecd3d JK	360	block_mig_state.transferred);
c163b5ca	361	}
	362
	363	static int is_stage2_completed(void)
	364	{
	365	BlkMigDevState *bmds;
a55eb92c	366
d11ecd3d	367	if (block_mig_state.submitted > 0) {
c163b5ca	368	return 0;
c163b5ca	369	}
a55eb92c	370
5e5328be	371	QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
a55eb92c	372	if (bmds->bulk_completed == 0) {
c163b5ca	373	return 0;
	374	}
	375	}
a55eb92c	376
c163b5ca	377	return 1;
	378	}
	379
7184049e	380	static void blk_mig_cleanup(Monitor *mon)
4ec7fcc7	381	{
82801d8f JK	382	BlkMigDevState *bmds;
82801d8f JK	383	BlkMigBlock *blk;
4ec7fcc7	384
82801d8f JK	385	while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) {
82801d8f JK	386	QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);
4ec7fcc7 JK	387	qemu_free(bmds);
	388	}
	389
82801d8f JK	390	while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
82801d8f JK	391	QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
4ec7fcc7 JK	392	qemu_free(blk->buf);
	393	qemu_free(blk);
	394	}
	395
	396	set_dirty_tracking(0);
	397
7184049e	398	monitor_printf(mon, "\n");
4ec7fcc7 JK	399	}
4ec7fcc7 JK	400
f327aa0c	401	static int block_save_live(Monitor mon, QEMUFile f, int stage, void *opaque)
c163b5ca	402	{
d0f2c4c6	403	DPRINTF("Enter save live stage %d submitted %d transferred %d\n",
d11ecd3d	404	stage, block_mig_state.submitted, block_mig_state.transferred);
a55eb92c	405
4ec7fcc7	406	if (stage < 0) {
7184049e	407	blk_mig_cleanup(mon);
4ec7fcc7 JK	408	return 0;
	409	}
	410
d11ecd3d	411	if (block_mig_state.blk_enable != 1) {
c163b5ca	412	/* no need to migrate storage */
a55eb92c	413	qemu_put_be64(f, BLK_MIG_FLAG_EOS);
c163b5ca	414	return 1;
c163b5ca	415	}
a55eb92c JK	416
a55eb92c JK	417	if (stage == 1) {
7184049e	418	init_blk_migration(mon, f);
a55eb92c	419
c163b5ca	420	/* start track dirty blocks */
c163b5ca	421	set_dirty_tracking(1);
c163b5ca	422	}
	423
	424	flush_blks(f);
a55eb92c	425
4b640365	426	if (qemu_file_has_error(f)) {
7184049e	427	blk_mig_cleanup(mon);
4b640365 JK	428	return 0;
	429	}
	430
c163b5ca	431	/* control the rate of transfer */
d11ecd3d JK	432	while ((block_mig_state.submitted +
d11ecd3d JK	433	block_mig_state.read_done) * BLOCK_SIZE <
a55eb92c	434	qemu_file_get_rate_limit(f)) {
7184049e	435	if (blk_mig_save_bulked_block(mon, f, 1) == 0) {
a55eb92c	436	/* no more bulk blocks for now */
c163b5ca	437	break;
a55eb92c	438	}
c163b5ca	439	}
a55eb92c	440
c163b5ca	441	flush_blks(f);
a55eb92c	442
4b640365	443	if (qemu_file_has_error(f)) {
7184049e	444	blk_mig_cleanup(mon);
4b640365 JK	445	return 0;
	446	}
	447
a55eb92c	448	if (stage == 3) {
7184049e	449	while (blk_mig_save_bulked_block(mon, f, 0) != 0) {
a55eb92c JK	450	/* empty */
	451	}
	452
7184049e JK	453	blk_mig_save_dirty_blocks(mon, f);
7184049e JK	454	blk_mig_cleanup(mon);
a55eb92c	455
01e61e2d JK	456	/* report completion */
	457	qemu_put_be64(f, (100 << BDRV_SECTOR_BITS) \| BLK_MIG_FLAG_PROGRESS);
	458
4b640365 JK	459	if (qemu_file_has_error(f)) {
	460	return 0;
	461	}
	462
7184049e	463	monitor_printf(mon, "Block migration completed\n");
c163b5ca	464	}
a55eb92c JK	465
	466	qemu_put_be64(f, BLK_MIG_FLAG_EOS);
	467
c163b5ca	468	return ((stage == 2) && is_stage2_completed());
	469	}
	470
	471	static int block_load(QEMUFile f, void opaque, int version_id)
	472	{
01e61e2d	473	static int banner_printed;
c163b5ca	474	int len, flags;
	475	char device_name[256];
	476	int64_t addr;
	477	BlockDriverState *bs;
	478	uint8_t *buf;
a55eb92c	479
c163b5ca	480	do {
c163b5ca	481	addr = qemu_get_be64(f);
a55eb92c	482
6ea44308 JK	483	flags = addr & ~BDRV_SECTOR_MASK;
6ea44308 JK	484	addr >>= BDRV_SECTOR_BITS;
a55eb92c JK	485
a55eb92c JK	486	if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
c163b5ca	487	/* get device name */
c163b5ca	488	len = qemu_get_byte(f);
c163b5ca	489	qemu_get_buffer(f, (uint8_t *)device_name, len);
c163b5ca	490	device_name[len] = '\0';
a55eb92c	491
c163b5ca	492	bs = bdrv_find(device_name);
4b640365 JK	493	if (!bs) {
	494	fprintf(stderr, "Error unknown block device %s\n",
	495	device_name);
	496	return -EINVAL;
	497	}
a55eb92c	498
575a58d7 JK	499	buf = qemu_malloc(BLOCK_SIZE);
575a58d7 JK	500
a55eb92c	501	qemu_get_buffer(f, buf, BLOCK_SIZE);
4b640365	502	bdrv_write(bs, addr, buf, BDRV_SECTORS_PER_DIRTY_CHUNK);
575a58d7 JK	503
575a58d7 JK	504	qemu_free(buf);
01e61e2d JK	505	} else if (flags & BLK_MIG_FLAG_PROGRESS) {
	506	if (!banner_printed) {
	507	printf("Receiving block device images\n");
	508	banner_printed = 1;
	509	}
	510	printf("Completed %d %%%c", (int)addr,
	511	(addr == 100) ? '\n' : '\r');
	512	fflush(stdout);
a55eb92c	513	} else if (!(flags & BLK_MIG_FLAG_EOS)) {
4b640365 JK	514	fprintf(stderr, "Unknown flags\n");
	515	return -EINVAL;
	516	}
	517	if (qemu_file_has_error(f)) {
	518	return -EIO;
c163b5ca	519	}
a55eb92c JK	520	} while (!(flags & BLK_MIG_FLAG_EOS));
a55eb92c JK	521
c163b5ca	522	return 0;
	523	}
	524
	525	static void block_set_params(int blk_enable, int shared_base, void *opaque)
	526	{
d11ecd3d JK	527	block_mig_state.blk_enable = blk_enable;
d11ecd3d JK	528	block_mig_state.shared_base = shared_base;
a55eb92c	529
c163b5ca	530	/* shared base means that blk_enable = 1 */
d11ecd3d	531	block_mig_state.blk_enable \|= shared_base;
c163b5ca	532	}
c163b5ca	533
c163b5ca	534	void blk_mig_init(void)
a55eb92c	535	{
5e5328be JK	536	QSIMPLEQ_INIT(&block_mig_state.bmds_list);
	537	QSIMPLEQ_INIT(&block_mig_state.blk_list);
	538
a55eb92c	539	register_savevm_live("block", 0, 1, block_set_params, block_save_live,
d11ecd3d	540	NULL, block_load, &block_mig_state);
c163b5ca	541	}