blob: 6ca48f4b3cd877b8a581a9b7f06240b97532667d [file] [log] [blame]
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +02001/*
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"
Jan Kiszka5e5328b2009-11-30 18:21:20 +010017#include "qemu-queue.h"
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020018#include "block-migration.h"
19#include <assert.h>
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020020
Jan Kiszka6ea44302009-11-30 18:21:19 +010021#define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020022
23#define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
24#define BLK_MIG_FLAG_EOS 0x02
25
26#define MAX_IS_ALLOCATED_SEARCH 65536
27#define MAX_BLOCKS_READ 10000
28#define BLOCKS_READ_CHANGE 100
29#define INITIAL_BLOCKS_READ 100
30
31//#define DEBUG_BLK_MIGRATION
32
33#ifdef DEBUG_BLK_MIGRATION
Jan Kiszkaa55eb922009-11-30 18:21:19 +010034#define dprintf(fmt, ...) \
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020035 do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0)
36#else
Jan Kiszkaa55eb922009-11-30 18:21:19 +010037#define dprintf(fmt, ...) \
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020038 do { } while (0)
39#endif
40
Jan Kiszkaa55eb922009-11-30 18:21:19 +010041typedef struct BlkMigDevState {
42 BlockDriverState *bs;
43 int bulk_completed;
44 int shared_base;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010045 int64_t cur_sector;
46 int64_t total_sectors;
47 int64_t dirty;
Jan Kiszka5e5328b2009-11-30 18:21:20 +010048 QSIMPLEQ_ENTRY(BlkMigDevState) entry;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010049} BlkMigDevState;
50
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020051typedef struct BlkMigBlock {
52 uint8_t *buf;
53 BlkMigDevState *bmds;
54 int64_t sector;
55 struct iovec iov;
56 QEMUIOVector qiov;
57 BlockDriverAIOCB *aiocb;
58 int ret;
Jan Kiszka5e5328b2009-11-30 18:21:20 +010059 QSIMPLEQ_ENTRY(BlkMigBlock) entry;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020060} BlkMigBlock;
61
62typedef struct BlkMigState {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020063 int blk_enable;
64 int shared_base;
Jan Kiszka5e5328b2009-11-30 18:21:20 +010065 QSIMPLEQ_HEAD(bmds_list, BlkMigDevState) bmds_list;
66 QSIMPLEQ_HEAD(blk_list, BlkMigBlock) blk_list;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020067 int submitted;
68 int read_done;
69 int transferred;
70 int64_t print_completion;
71} BlkMigState;
72
Jan Kiszkad11ecd32009-11-30 18:21:20 +010073static BlkMigState block_mig_state;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020074
75static void blk_mig_read_cb(void *opaque, int ret)
76{
77 BlkMigBlock *blk = opaque;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010078
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020079 blk->ret = ret;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010080
Jan Kiszka5e5328b2009-11-30 18:21:20 +010081 QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry);
Jan Kiszkaa55eb922009-11-30 18:21:19 +010082
Jan Kiszkad11ecd32009-11-30 18:21:20 +010083 block_mig_state.submitted--;
84 block_mig_state.read_done++;
85 assert(block_mig_state.submitted >= 0);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020086}
87
88static int mig_read_device_bulk(QEMUFile *f, BlkMigDevState *bms)
Jan Kiszkaa55eb922009-11-30 18:21:19 +010089{
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020090 int nr_sectors;
91 int64_t total_sectors, cur_sector = 0;
92 BlockDriverState *bs = bms->bs;
93 BlkMigBlock *blk;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010094
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020095 blk = qemu_malloc(sizeof(BlkMigBlock));
96 blk->buf = qemu_malloc(BLOCK_SIZE);
Jan Kiszkaa55eb922009-11-30 18:21:19 +010097
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020098 cur_sector = bms->cur_sector;
Jan Kiszka6ea44302009-11-30 18:21:19 +010099 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100100
101 if (bms->shared_base) {
102 while (cur_sector < bms->total_sectors &&
103 !bdrv_is_allocated(bms->bs, cur_sector,
104 MAX_IS_ALLOCATED_SEARCH, &nr_sectors)) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200105 cur_sector += nr_sectors;
106 }
107 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100108
109 if (cur_sector >= total_sectors) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200110 bms->cur_sector = total_sectors;
111 qemu_free(blk->buf);
112 qemu_free(blk);
113 return 1;
114 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100115
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100116 if (cur_sector >= block_mig_state.print_completion) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200117 printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
118 fflush(stdout);
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100119 block_mig_state.print_completion +=
Jan Kiszka6ea44302009-11-30 18:21:19 +0100120 (BDRV_SECTORS_PER_DIRTY_CHUNK * 10000);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200121 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100122
Jan Kiszka6ea44302009-11-30 18:21:19 +0100123 /* we are going to transfer a full block even if it is not allocated */
124 nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200125
Jan Kiszka6ea44302009-11-30 18:21:19 +0100126 cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100127
Jan Kiszka6ea44302009-11-30 18:21:19 +0100128 if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200129 nr_sectors = (total_sectors - cur_sector);
130 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100131
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200132 bms->cur_sector = cur_sector + nr_sectors;
133 blk->sector = cur_sector;
134 blk->bmds = bms;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100135
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200136 blk->iov.iov_base = blk->buf;
Jan Kiszka6ea44302009-11-30 18:21:19 +0100137 blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200138 qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100139
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200140 blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
141 nr_sectors, blk_mig_read_cb, blk);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100142
143 if (!blk->aiocb) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200144 printf("Error reading sector %" PRId64 "\n", cur_sector);
145 qemu_free(blk->buf);
146 qemu_free(blk);
147 return 0;
148 }
149
150 bdrv_reset_dirty(bms->bs, cur_sector, nr_sectors);
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100151 block_mig_state.submitted++;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100152
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200153 return (bms->cur_sector >= total_sectors);
154}
155
156static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100157{
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200158 int len, nr_sectors;
159 int64_t total_sectors = bmds->total_sectors, cur_sector = 0;
160 uint8_t *tmp_buf = NULL;
161 BlockDriverState *bs = bmds->bs;
162
163 tmp_buf = qemu_malloc(BLOCK_SIZE);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100164
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200165 cur_sector = bmds->cur_sector;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100166
167 if (bmds->shared_base) {
168 while (cur_sector < bmds->total_sectors &&
169 !bdrv_is_allocated(bmds->bs, cur_sector,
170 MAX_IS_ALLOCATED_SEARCH, &nr_sectors)) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200171 cur_sector += nr_sectors;
172 }
173 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100174
175 if (cur_sector >= total_sectors) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200176 bmds->cur_sector = total_sectors;
177 qemu_free(tmp_buf);
178 return 1;
179 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100180
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100181 if (cur_sector >= block_mig_state.print_completion) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200182 printf("Completed %" PRId64 " %%\r", cur_sector * 100 / total_sectors);
183 fflush(stdout);
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100184 block_mig_state.print_completion +=
Jan Kiszka6ea44302009-11-30 18:21:19 +0100185 (BDRV_SECTORS_PER_DIRTY_CHUNK * 10000);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200186 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100187
Jan Kiszka6ea44302009-11-30 18:21:19 +0100188 cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100189
Jan Kiszka6ea44302009-11-30 18:21:19 +0100190 /* we are going to transfer a full block even if it is not allocated */
191 nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100192
Jan Kiszka6ea44302009-11-30 18:21:19 +0100193 if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200194 nr_sectors = (total_sectors - cur_sector);
195 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100196
197 if (bdrv_read(bs, cur_sector, tmp_buf, nr_sectors) < 0) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200198 printf("Error reading sector %" PRId64 "\n", cur_sector);
199 }
200
201 bdrv_reset_dirty(bs, cur_sector, nr_sectors);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100202
203 /* sector number and flags */
Jan Kiszka6ea44302009-11-30 18:21:19 +0100204 qemu_put_be64(f, (cur_sector << BDRV_SECTOR_BITS)
205 | BLK_MIG_FLAG_DEVICE_BLOCK);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100206
207 /* device name */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200208 len = strlen(bs->device_name);
209 qemu_put_byte(f, len);
210 qemu_put_buffer(f, (uint8_t *)bs->device_name, len);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100211
212 qemu_put_buffer(f, tmp_buf, BLOCK_SIZE);
213
Jan Kiszka6ea44302009-11-30 18:21:19 +0100214 bmds->cur_sector = cur_sector + BDRV_SECTORS_PER_DIRTY_CHUNK;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100215
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200216 qemu_free(tmp_buf);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100217
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200218 return (bmds->cur_sector >= total_sectors);
219}
220
221static void send_blk(QEMUFile *f, BlkMigBlock * blk)
222{
223 int len;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100224
225 /* sector number and flags */
Jan Kiszka6ea44302009-11-30 18:21:19 +0100226 qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS)
227 | BLK_MIG_FLAG_DEVICE_BLOCK);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100228
229 /* device name */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200230 len = strlen(blk->bmds->bs->device_name);
231 qemu_put_byte(f, len);
232 qemu_put_buffer(f, (uint8_t *)blk->bmds->bs->device_name, len);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100233
234 qemu_put_buffer(f, blk->buf, BLOCK_SIZE);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200235}
236
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200237static void set_dirty_tracking(int enable)
238{
239 BlkMigDevState *bmds;
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100240
241 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100242 bdrv_set_dirty_tracking(bmds->bs, enable);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200243 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200244}
245
246static void init_blk_migration(QEMUFile *f)
247{
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100248 BlkMigDevState *bmds;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200249 BlockDriverState *bs;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100250
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200251 for (bs = bdrv_first; bs != NULL; bs = bs->next) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100252 if (bs->type == BDRV_TYPE_HD) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200253 bmds = qemu_mallocz(sizeof(BlkMigDevState));
254 bmds->bs = bs;
255 bmds->bulk_completed = 0;
Jan Kiszka6ea44302009-11-30 18:21:19 +0100256 bmds->total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100257 bmds->shared_base = block_mig_state.shared_base;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100258
259 if (bmds->shared_base) {
260 printf("Start migration for %s with shared base image\n",
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200261 bs->device_name);
262 } else {
263 printf("Start full migration for %s\n", bs->device_name);
264 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100265
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100266 QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200267 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100268 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200269}
270
271static int blk_mig_save_bulked_block(QEMUFile *f, int is_async)
272{
273 BlkMigDevState *bmds;
274
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100275 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100276 if (bmds->bulk_completed == 0) {
277 if (is_async) {
278 if (mig_read_device_bulk(f, bmds) == 1) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200279 /* completed bulk section for this device */
280 bmds->bulk_completed = 1;
281 }
282 } else {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100283 if (mig_save_device_bulk(f, bmds) == 1) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200284 /* completed bulk section for this device */
285 bmds->bulk_completed = 1;
286 }
287 }
288 return 1;
289 }
290 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100291
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200292 /* we reached here means bulk is completed */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200293 return 0;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200294}
295
296#define MAX_NUM_BLOCKS 4
297
298static void blk_mig_save_dirty_blocks(QEMUFile *f)
299{
300 BlkMigDevState *bmds;
Jan Kiszka575a58d2009-11-30 18:21:20 +0100301 uint8_t *buf;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200302 int64_t sector;
303 int len;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100304
Jan Kiszka575a58d2009-11-30 18:21:20 +0100305 buf = qemu_malloc(BLOCK_SIZE);
306
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100307 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100308 for (sector = 0; sector < bmds->cur_sector;) {
309 if (bdrv_get_dirty(bmds->bs, sector)) {
310 if (bdrv_read(bmds->bs, sector, buf,
Jan Kiszka6ea44302009-11-30 18:21:19 +0100311 BDRV_SECTORS_PER_DIRTY_CHUNK) < 0) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100312 /* FIXME: add error handling */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200313 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100314
315 /* sector number and flags */
Jan Kiszka6ea44302009-11-30 18:21:19 +0100316 qemu_put_be64(f, (sector << BDRV_SECTOR_BITS)
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100317 | BLK_MIG_FLAG_DEVICE_BLOCK);
318
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200319 /* device name */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200320 len = strlen(bmds->bs->device_name);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200321 qemu_put_byte(f, len);
322 qemu_put_buffer(f, (uint8_t *)bmds->bs->device_name, len);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100323
Jan Kiszka6ea44302009-11-30 18:21:19 +0100324 qemu_put_buffer(f, buf, BLOCK_SIZE);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100325
326 bdrv_reset_dirty(bmds->bs, sector,
Jan Kiszka6ea44302009-11-30 18:21:19 +0100327 BDRV_SECTORS_PER_DIRTY_CHUNK);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100328 }
Jan Kiszka6ea44302009-11-30 18:21:19 +0100329 sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200330 }
331 }
Jan Kiszka575a58d2009-11-30 18:21:20 +0100332
333 qemu_free(buf);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200334}
335
336static void flush_blks(QEMUFile* f)
337{
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100338 BlkMigBlock *blk;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100339
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100340 dprintf("%s Enter submitted %d read_done %d transferred %d\n",
341 __FUNCTION__, block_mig_state.submitted, block_mig_state.read_done,
342 block_mig_state.transferred);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100343
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100344 while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
345 if (qemu_file_rate_limit(f)) {
346 break;
347 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200348 send_blk(f, blk);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100349
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100350 QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200351 qemu_free(blk->buf);
352 qemu_free(blk);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100353
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100354 block_mig_state.read_done--;
355 block_mig_state.transferred++;
356 assert(block_mig_state.read_done >= 0);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200357 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200358
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100359 dprintf("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__,
360 block_mig_state.submitted, block_mig_state.read_done,
361 block_mig_state.transferred);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200362}
363
364static int is_stage2_completed(void)
365{
366 BlkMigDevState *bmds;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100367
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100368 if (block_mig_state.submitted > 0) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200369 return 0;
370 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100371
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100372 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100373 if (bmds->bulk_completed == 0) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200374 return 0;
375 }
376 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100377
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200378 return 1;
379}
380
381static int block_save_live(QEMUFile *f, int stage, void *opaque)
382{
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100383 dprintf("Enter save live stage %d submitted %d transferred %d\n",
384 stage, block_mig_state.submitted, block_mig_state.transferred);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100385
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100386 if (block_mig_state.blk_enable != 1) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200387 /* no need to migrate storage */
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100388 qemu_put_be64(f, BLK_MIG_FLAG_EOS);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200389 return 1;
390 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100391
392 if (stage == 1) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200393 init_blk_migration(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100394
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200395 /* start track dirty blocks */
396 set_dirty_tracking(1);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200397 }
398
399 flush_blks(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100400
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200401 /* control the rate of transfer */
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100402 while ((block_mig_state.submitted +
403 block_mig_state.read_done) * BLOCK_SIZE <
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100404 qemu_file_get_rate_limit(f)) {
405 if (blk_mig_save_bulked_block(f, 1) == 0) {
406 /* no more bulk blocks for now */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200407 break;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100408 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200409 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100410
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200411 flush_blks(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100412
413 if (stage == 3) {
414 while (blk_mig_save_bulked_block(f, 0) != 0) {
415 /* empty */
416 }
417
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200418 blk_mig_save_dirty_blocks(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100419
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200420 /* stop track dirty blocks */
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100421 set_dirty_tracking(0);
422
423 printf("\nBlock migration completed\n");
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200424 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100425
426 qemu_put_be64(f, BLK_MIG_FLAG_EOS);
427
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200428 return ((stage == 2) && is_stage2_completed());
429}
430
431static int block_load(QEMUFile *f, void *opaque, int version_id)
432{
433 int len, flags;
434 char device_name[256];
435 int64_t addr;
436 BlockDriverState *bs;
437 uint8_t *buf;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100438
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200439 do {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200440 addr = qemu_get_be64(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100441
Jan Kiszka6ea44302009-11-30 18:21:19 +0100442 flags = addr & ~BDRV_SECTOR_MASK;
443 addr >>= BDRV_SECTOR_BITS;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100444
445 if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200446 /* get device name */
447 len = qemu_get_byte(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100448
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200449 qemu_get_buffer(f, (uint8_t *)device_name, len);
450 device_name[len] = '\0';
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100451
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200452 bs = bdrv_find(device_name);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100453
Jan Kiszka575a58d2009-11-30 18:21:20 +0100454 buf = qemu_malloc(BLOCK_SIZE);
455
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100456 qemu_get_buffer(f, buf, BLOCK_SIZE);
457 if (bs != NULL) {
Jan Kiszka6ea44302009-11-30 18:21:19 +0100458 bdrv_write(bs, addr, buf, BDRV_SECTORS_PER_DIRTY_CHUNK);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200459 } else {
460 printf("Error unknown block device %s\n", device_name);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100461 /* FIXME: add error handling */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200462 }
Jan Kiszka575a58d2009-11-30 18:21:20 +0100463
464 qemu_free(buf);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100465 } else if (!(flags & BLK_MIG_FLAG_EOS)) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200466 printf("Unknown flags\n");
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100467 /* FIXME: add error handling */
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200468 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100469 } while (!(flags & BLK_MIG_FLAG_EOS));
470
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200471 return 0;
472}
473
474static void block_set_params(int blk_enable, int shared_base, void *opaque)
475{
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100476 block_mig_state.blk_enable = blk_enable;
477 block_mig_state.shared_base = shared_base;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100478
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200479 /* shared base means that blk_enable = 1 */
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100480 block_mig_state.blk_enable |= shared_base;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200481}
482
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200483void blk_mig_init(void)
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100484{
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100485 QSIMPLEQ_INIT(&block_mig_state.bmds_list);
486 QSIMPLEQ_INIT(&block_mig_state.blk_list);
487
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100488 register_savevm_live("block", 0, 1, block_set_params, block_save_live,
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100489 NULL, block_load, &block_mig_state);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200490}