blob: 423c5a07b6ff81d42627179cefff69c325d90cc1 [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"
Liran Schour889ae392010-01-26 10:31:49 +020018#include "qemu-timer.h"
Jan Kiszka71840492009-11-30 18:21:21 +010019#include "monitor.h"
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020020#include "block-migration.h"
Liran Schour889ae392010-01-26 10:31:49 +020021#include "migration.h"
Marcelo Tosattif48905d2011-01-26 12:12:33 -020022#include "blockdev.h"
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020023#include <assert.h>
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020024
Jan Kiszka6ea44302009-11-30 18:21:19 +010025#define BLOCK_SIZE (BDRV_SECTORS_PER_DIRTY_CHUNK << BDRV_SECTOR_BITS)
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020026
27#define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
28#define BLK_MIG_FLAG_EOS 0x02
Jan Kiszka01e61e22009-12-01 15:20:17 +010029#define BLK_MIG_FLAG_PROGRESS 0x04
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020030
31#define MAX_IS_ALLOCATED_SEARCH 65536
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020032
33//#define DEBUG_BLK_MIGRATION
34
35#ifdef DEBUG_BLK_MIGRATION
malcd0f2c4c2010-02-07 02:03:50 +030036#define DPRINTF(fmt, ...) \
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020037 do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0)
38#else
malcd0f2c4c2010-02-07 02:03:50 +030039#define DPRINTF(fmt, ...) \
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020040 do { } while (0)
41#endif
42
Jan Kiszkaa55eb922009-11-30 18:21:19 +010043typedef struct BlkMigDevState {
44 BlockDriverState *bs;
45 int bulk_completed;
46 int shared_base;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010047 int64_t cur_sector;
Liran Schourd76cac72010-01-26 14:04:11 +020048 int64_t cur_dirty;
Jan Kiszka82801d82009-11-30 18:21:21 +010049 int64_t completed_sectors;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010050 int64_t total_sectors;
51 int64_t dirty;
Jan Kiszka5e5328b2009-11-30 18:21:20 +010052 QSIMPLEQ_ENTRY(BlkMigDevState) entry;
Marcelo Tosatti33656af2010-11-08 17:02:56 -020053 unsigned long *aio_bitmap;
Jan Kiszkaa55eb922009-11-30 18:21:19 +010054} BlkMigDevState;
55
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020056typedef struct BlkMigBlock {
57 uint8_t *buf;
58 BlkMigDevState *bmds;
59 int64_t sector;
Marcelo Tosatti33656af2010-11-08 17:02:56 -020060 int nr_sectors;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020061 struct iovec iov;
62 QEMUIOVector qiov;
63 BlockDriverAIOCB *aiocb;
64 int ret;
Jan Kiszka5e5328b2009-11-30 18:21:20 +010065 QSIMPLEQ_ENTRY(BlkMigBlock) entry;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020066} BlkMigBlock;
67
68typedef struct BlkMigState {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020069 int blk_enable;
70 int shared_base;
Jan Kiszka5e5328b2009-11-30 18:21:20 +010071 QSIMPLEQ_HEAD(bmds_list, BlkMigDevState) bmds_list;
72 QSIMPLEQ_HEAD(blk_list, BlkMigBlock) blk_list;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020073 int submitted;
74 int read_done;
75 int transferred;
Jan Kiszka82801d82009-11-30 18:21:21 +010076 int64_t total_sector_sum;
Jan Kiszka01e61e22009-12-01 15:20:17 +010077 int prev_progress;
Liran Schoure970ec02010-01-26 10:31:45 +020078 int bulk_completed;
Liran Schour889ae392010-01-26 10:31:49 +020079 long double total_time;
Avishay Traegerff5c52a2011-04-03 11:31:45 +030080 long double prev_time_offset;
Liran Schour889ae392010-01-26 10:31:49 +020081 int reads;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020082} BlkMigState;
83
Jan Kiszkad11ecd32009-11-30 18:21:20 +010084static BlkMigState block_mig_state;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +020085
Jan Kiszka13f0b672009-11-30 18:21:21 +010086static void blk_send(QEMUFile *f, BlkMigBlock * blk)
87{
88 int len;
89
90 /* sector number and flags */
91 qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS)
92 | BLK_MIG_FLAG_DEVICE_BLOCK);
93
94 /* device name */
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);
98
99 qemu_put_buffer(f, blk->buf, BLOCK_SIZE);
100}
101
Jan Kiszka25f23642009-11-30 18:21:21 +0100102int blk_mig_active(void)
103{
104 return !QSIMPLEQ_EMPTY(&block_mig_state.bmds_list);
105}
106
107uint64_t blk_mig_bytes_transferred(void)
108{
109 BlkMigDevState *bmds;
110 uint64_t sum = 0;
111
112 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
113 sum += bmds->completed_sectors;
114 }
115 return sum << BDRV_SECTOR_BITS;
116}
117
118uint64_t blk_mig_bytes_remaining(void)
119{
120 return blk_mig_bytes_total() - blk_mig_bytes_transferred();
121}
122
123uint64_t blk_mig_bytes_total(void)
124{
125 BlkMigDevState *bmds;
126 uint64_t sum = 0;
127
128 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
129 sum += bmds->total_sectors;
130 }
131 return sum << BDRV_SECTOR_BITS;
132}
133
Liran Schour889ae392010-01-26 10:31:49 +0200134static inline long double compute_read_bwidth(void)
135{
136 assert(block_mig_state.total_time != 0);
Avishay Traeger155eb9a2011-04-06 10:45:36 +0300137 return (block_mig_state.reads / block_mig_state.total_time) * BLOCK_SIZE;
Liran Schour889ae392010-01-26 10:31:49 +0200138}
139
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200140static int bmds_aio_inflight(BlkMigDevState *bmds, int64_t sector)
141{
142 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
143
Marcelo Tosatti62155e22010-11-12 16:07:50 -0200144 if ((sector << BDRV_SECTOR_BITS) < bdrv_getlength(bmds->bs)) {
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200145 return !!(bmds->aio_bitmap[chunk / (sizeof(unsigned long) * 8)] &
146 (1UL << (chunk % (sizeof(unsigned long) * 8))));
147 } else {
148 return 0;
149 }
150}
151
152static void bmds_set_aio_inflight(BlkMigDevState *bmds, int64_t sector_num,
153 int nb_sectors, int set)
154{
155 int64_t start, end;
156 unsigned long val, idx, bit;
157
158 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
159 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
160
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];
165 if (set) {
Marcelo Tosatti62155e22010-11-12 16:07:50 -0200166 val |= 1UL << bit;
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200167 } else {
Marcelo Tosatti62155e22010-11-12 16:07:50 -0200168 val &= ~(1UL << bit);
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200169 }
170 bmds->aio_bitmap[idx] = val;
171 }
172}
173
174static void alloc_aio_bitmap(BlkMigDevState *bmds)
175{
176 BlockDriverState *bs = bmds->bs;
177 int64_t bitmap_size;
178
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;
182
Anthony Liguori7267c092011-08-20 22:09:37 -0500183 bmds->aio_bitmap = g_malloc0(bitmap_size);
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200184}
185
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200186static void blk_mig_read_cb(void *opaque, int ret)
187{
Avishay Traegerff5c52a2011-04-03 11:31:45 +0300188 long double curr_time = qemu_get_clock_ns(rt_clock);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200189 BlkMigBlock *blk = opaque;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100190
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200191 blk->ret = ret;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100192
Avishay Traegerff5c52a2011-04-03 11:31:45 +0300193 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;
Liran Schour889ae392010-01-26 10:31:49 +0200196
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100197 QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry);
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200198 bmds_set_aio_inflight(blk->bmds, blk->sector, blk->nr_sectors, 0);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100199
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100200 block_mig_state.submitted--;
201 block_mig_state.read_done++;
202 assert(block_mig_state.submitted >= 0);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200203}
204
Jan Kiszka71840492009-11-30 18:21:21 +0100205static int mig_save_device_bulk(Monitor *mon, QEMUFile *f,
Liran Schoure970ec02010-01-26 10:31:45 +0200206 BlkMigDevState *bmds)
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100207{
Jan Kiszka57cce122009-11-30 18:21:20 +0100208 int64_t total_sectors = bmds->total_sectors;
209 int64_t cur_sector = bmds->cur_sector;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200210 BlockDriverState *bs = bmds->bs;
Jan Kiszka57cce122009-11-30 18:21:20 +0100211 BlkMigBlock *blk;
Jan Kiszka13f0b672009-11-30 18:21:21 +0100212 int nr_sectors;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100213
214 if (bmds->shared_base) {
Jan Kiszkab1d10852009-11-30 18:21:20 +0100215 while (cur_sector < total_sectors &&
Jan Kiszka57cce122009-11-30 18:21:20 +0100216 !bdrv_is_allocated(bs, cur_sector, MAX_IS_ALLOCATED_SEARCH,
217 &nr_sectors)) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200218 cur_sector += nr_sectors;
219 }
220 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100221
222 if (cur_sector >= total_sectors) {
Jan Kiszka82801d82009-11-30 18:21:21 +0100223 bmds->cur_sector = bmds->completed_sectors = total_sectors;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200224 return 1;
225 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100226
Jan Kiszka82801d82009-11-30 18:21:21 +0100227 bmds->completed_sectors = cur_sector;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100228
Jan Kiszka6ea44302009-11-30 18:21:19 +0100229 cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100230
Jan Kiszka6ea44302009-11-30 18:21:19 +0100231 /* we are going to transfer a full block even if it is not allocated */
232 nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100233
Jan Kiszka6ea44302009-11-30 18:21:19 +0100234 if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
Jan Kiszka57cce122009-11-30 18:21:20 +0100235 nr_sectors = total_sectors - cur_sector;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200236 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100237
Anthony Liguori7267c092011-08-20 22:09:37 -0500238 blk = g_malloc(sizeof(BlkMigBlock));
239 blk->buf = g_malloc(BLOCK_SIZE);
Jan Kiszka13f0b672009-11-30 18:21:21 +0100240 blk->bmds = bmds;
241 blk->sector = cur_sector;
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200242 blk->nr_sectors = nr_sectors;
Jan Kiszka13f0b672009-11-30 18:21:21 +0100243
Liran Schoure970ec02010-01-26 10:31:45 +0200244 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);
Jan Kiszka57cce122009-11-30 18:21:20 +0100247
Avishay Traegerff5c52a2011-04-03 11:31:45 +0300248 if (block_mig_state.submitted == 0) {
249 block_mig_state.prev_time_offset = qemu_get_clock_ns(rt_clock);
250 }
Liran Schour889ae392010-01-26 10:31:49 +0200251
Liran Schoure970ec02010-01-26 10:31:45 +0200252 blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,
253 nr_sectors, blk_mig_read_cb, blk);
254 if (!blk->aiocb) {
255 goto error;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200256 }
Liran Schoure970ec02010-01-26 10:31:45 +0200257 block_mig_state.submitted++;
Liran Schourd76cac72010-01-26 14:04:11 +0200258
Jan Kiszka13f0b672009-11-30 18:21:21 +0100259 bdrv_reset_dirty(bs, cur_sector, nr_sectors);
260 bmds->cur_sector = cur_sector + nr_sectors;
261
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200262 return (bmds->cur_sector >= total_sectors);
Jan Kiszka4b640362009-11-30 18:21:21 +0100263
264error:
Jan Kiszka71840492009-11-30 18:21:21 +0100265 monitor_printf(mon, "Error reading sector %" PRId64 "\n", cur_sector);
Juan Quinteladcd1d222011-09-21 23:01:54 +0200266 qemu_file_set_error(f, -EIO);
Anthony Liguori7267c092011-08-20 22:09:37 -0500267 g_free(blk->buf);
268 g_free(blk);
Jan Kiszka4b640362009-11-30 18:21:21 +0100269 return 0;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200270}
271
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200272static void set_dirty_tracking(int enable)
273{
274 BlkMigDevState *bmds;
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100275
276 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100277 bdrv_set_dirty_tracking(bmds->bs, enable);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200278 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200279}
280
Stefan Hajnoczib66460e2010-04-09 15:22:13 +0100281static void init_blk_migration_it(void *opaque, BlockDriverState *bs)
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200282{
Stefan Hajnoczib66460e2010-04-09 15:22:13 +0100283 Monitor *mon = opaque;
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100284 BlkMigDevState *bmds;
Jan Kiszka792773b2009-11-30 20:34:55 +0100285 int64_t sectors;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100286
Markus Armbrusterd2466732010-06-28 10:45:02 +0200287 if (!bdrv_is_read_only(bs)) {
Stefan Hajnoczib66460e2010-04-09 15:22:13 +0100288 sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
Shahar Havivi31f54f22010-07-10 18:59:06 +0300289 if (sectors <= 0) {
Stefan Hajnoczib66460e2010-04-09 15:22:13 +0100290 return;
291 }
292
Anthony Liguori7267c092011-08-20 22:09:37 -0500293 bmds = g_malloc0(sizeof(BlkMigDevState));
Stefan Hajnoczib66460e2010-04-09 15:22:13 +0100294 bmds->bs = bs;
295 bmds->bulk_completed = 0;
296 bmds->total_sectors = sectors;
297 bmds->completed_sectors = 0;
298 bmds->shared_base = block_mig_state.shared_base;
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200299 alloc_aio_bitmap(bmds);
Marcelo Tosattif48905d2011-01-26 12:12:33 -0200300 drive_get_ref(drive_get_by_blockdev(bs));
Marcelo Tosatti85916752011-01-26 12:12:35 -0200301 bdrv_set_in_use(bs, 1);
Stefan Hajnoczib66460e2010-04-09 15:22:13 +0100302
303 block_mig_state.total_sector_sum += sectors;
304
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);
312 }
313
314 QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry);
315 }
316}
317
318static void init_blk_migration(Monitor *mon, QEMUFile *f)
319{
Jan Kiszka69d63a92009-11-30 18:21:20 +0100320 block_mig_state.submitted = 0;
321 block_mig_state.read_done = 0;
322 block_mig_state.transferred = 0;
Jan Kiszka82801d82009-11-30 18:21:21 +0100323 block_mig_state.total_sector_sum = 0;
Jan Kiszka01e61e22009-12-01 15:20:17 +0100324 block_mig_state.prev_progress = -1;
Liran Schoure970ec02010-01-26 10:31:45 +0200325 block_mig_state.bulk_completed = 0;
Liran Schour889ae392010-01-26 10:31:49 +0200326 block_mig_state.total_time = 0;
327 block_mig_state.reads = 0;
Jan Kiszka69d63a92009-11-30 18:21:20 +0100328
Stefan Hajnoczib66460e2010-04-09 15:22:13 +0100329 bdrv_iterate(init_blk_migration_it, mon);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200330}
331
Liran Schoure970ec02010-01-26 10:31:45 +0200332static int blk_mig_save_bulked_block(Monitor *mon, QEMUFile *f)
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200333{
Jan Kiszka82801d82009-11-30 18:21:21 +0100334 int64_t completed_sector_sum = 0;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200335 BlkMigDevState *bmds;
Jan Kiszka01e61e22009-12-01 15:20:17 +0100336 int progress;
Jan Kiszka82801d82009-11-30 18:21:21 +0100337 int ret = 0;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200338
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100339 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100340 if (bmds->bulk_completed == 0) {
Liran Schoure970ec02010-01-26 10:31:45 +0200341 if (mig_save_device_bulk(mon, f, bmds) == 1) {
Jan Kiszka57cce122009-11-30 18:21:20 +0100342 /* completed bulk section for this device */
343 bmds->bulk_completed = 1;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200344 }
Jan Kiszka82801d82009-11-30 18:21:21 +0100345 completed_sector_sum += bmds->completed_sectors;
346 ret = 1;
347 break;
348 } else {
349 completed_sector_sum += bmds->completed_sectors;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200350 }
351 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100352
Pierre Riteau8b6b2af2011-01-12 14:41:00 +0100353 if (block_mig_state.total_sector_sum != 0) {
354 progress = completed_sector_sum * 100 /
355 block_mig_state.total_sector_sum;
356 } else {
357 progress = 100;
358 }
Jan Kiszka01e61e22009-12-01 15:20:17 +0100359 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);
Jan Kiszka71840492009-11-30 18:21:21 +0100364 monitor_flush(mon);
Jan Kiszka82801d82009-11-30 18:21:21 +0100365 }
366
367 return ret;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200368}
369
Liran Schourd76cac72010-01-26 14:04:11 +0200370static void blk_mig_reset_dirty_cursor(void)
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200371{
372 BlkMigDevState *bmds;
Jan Kiszka575a58d2009-11-30 18:21:20 +0100373
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100374 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Liran Schourd76cac72010-01-26 14:04:11 +0200375 bmds->cur_dirty = 0;
376 }
377}
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100378
Liran Schourd76cac72010-01-26 14:04:11 +0200379static int mig_save_device_dirty(Monitor *mon, QEMUFile *f,
380 BlkMigDevState *bmds, int is_async)
381{
382 BlkMigBlock *blk;
383 int64_t total_sectors = bmds->total_sectors;
384 int64_t sector;
385 int nr_sectors;
Juan Quinteladcd1d222011-09-21 23:01:54 +0200386 int ret = -EIO;
Liran Schourd76cac72010-01-26 14:04:11 +0200387
388 for (sector = bmds->cur_dirty; sector < bmds->total_sectors;) {
Marcelo Tosatti62155e22010-11-12 16:07:50 -0200389 if (bmds_aio_inflight(bmds, sector)) {
Stefan Hajnoczi922453b2011-11-30 12:23:43 +0000390 bdrv_drain_all();
Marcelo Tosatti62155e22010-11-12 16:07:50 -0200391 }
Liran Schourd76cac72010-01-26 14:04:11 +0200392 if (bdrv_get_dirty(bmds->bs, sector)) {
393
394 if (total_sectors - sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
395 nr_sectors = total_sectors - sector;
396 } else {
397 nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100398 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500399 blk = g_malloc(sizeof(BlkMigBlock));
400 blk->buf = g_malloc(BLOCK_SIZE);
Liran Schourd76cac72010-01-26 14:04:11 +0200401 blk->bmds = bmds;
402 blk->sector = sector;
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200403 blk->nr_sectors = nr_sectors;
Liran Schourd76cac72010-01-26 14:04:11 +0200404
Liran Schour889ae392010-01-26 10:31:49 +0200405 if (is_async) {
Liran Schourd76cac72010-01-26 14:04:11 +0200406 blk->iov.iov_base = blk->buf;
407 blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
408 qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
409
Avishay Traegerff5c52a2011-04-03 11:31:45 +0300410 if (block_mig_state.submitted == 0) {
411 block_mig_state.prev_time_offset = qemu_get_clock_ns(rt_clock);
412 }
Liran Schour889ae392010-01-26 10:31:49 +0200413
Liran Schourd76cac72010-01-26 14:04:11 +0200414 blk->aiocb = bdrv_aio_readv(bmds->bs, sector, &blk->qiov,
415 nr_sectors, blk_mig_read_cb, blk);
416 if (!blk->aiocb) {
417 goto error;
418 }
419 block_mig_state.submitted++;
Marcelo Tosatti33656af2010-11-08 17:02:56 -0200420 bmds_set_aio_inflight(bmds, sector, nr_sectors, 1);
Liran Schourd76cac72010-01-26 14:04:11 +0200421 } else {
Juan Quinteladcd1d222011-09-21 23:01:54 +0200422 ret = bdrv_read(bmds->bs, sector, blk->buf, nr_sectors);
423 if (ret < 0) {
Liran Schourd76cac72010-01-26 14:04:11 +0200424 goto error;
425 }
426 blk_send(f, blk);
427
Anthony Liguori7267c092011-08-20 22:09:37 -0500428 g_free(blk->buf);
429 g_free(blk);
Liran Schourd76cac72010-01-26 14:04:11 +0200430 }
431
432 bdrv_reset_dirty(bmds->bs, sector, nr_sectors);
433 break;
434 }
435 sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
436 bmds->cur_dirty = sector;
437 }
438
439 return (bmds->cur_dirty >= bmds->total_sectors);
440
Liran Schour889ae392010-01-26 10:31:49 +0200441error:
Liran Schourd76cac72010-01-26 14:04:11 +0200442 monitor_printf(mon, "Error reading sector %" PRId64 "\n", sector);
Juan Quinteladcd1d222011-09-21 23:01:54 +0200443 qemu_file_set_error(f, ret);
Anthony Liguori7267c092011-08-20 22:09:37 -0500444 g_free(blk->buf);
445 g_free(blk);
Liran Schourd76cac72010-01-26 14:04:11 +0200446 return 0;
447}
448
449static int blk_mig_save_dirty_block(Monitor *mon, QEMUFile *f, int is_async)
450{
451 BlkMigDevState *bmds;
452 int ret = 0;
453
454 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
Liran Schour889ae392010-01-26 10:31:49 +0200455 if (mig_save_device_dirty(mon, f, bmds, is_async) == 0) {
Liran Schourd76cac72010-01-26 14:04:11 +0200456 ret = 1;
457 break;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200458 }
459 }
Jan Kiszka575a58d2009-11-30 18:21:20 +0100460
Liran Schourd76cac72010-01-26 14:04:11 +0200461 return ret;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200462}
463
464static void flush_blks(QEMUFile* f)
465{
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100466 BlkMigBlock *blk;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100467
malcd0f2c4c2010-02-07 02:03:50 +0300468 DPRINTF("%s Enter submitted %d read_done %d transferred %d\n",
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100469 __FUNCTION__, block_mig_state.submitted, block_mig_state.read_done,
470 block_mig_state.transferred);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100471
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100472 while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
473 if (qemu_file_rate_limit(f)) {
474 break;
475 }
Jan Kiszka4b640362009-11-30 18:21:21 +0100476 if (blk->ret < 0) {
Juan Quinteladcd1d222011-09-21 23:01:54 +0200477 qemu_file_set_error(f, blk->ret);
Jan Kiszka4b640362009-11-30 18:21:21 +0100478 break;
479 }
Jan Kiszka13f0b672009-11-30 18:21:21 +0100480 blk_send(f, blk);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100481
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100482 QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
Anthony Liguori7267c092011-08-20 22:09:37 -0500483 g_free(blk->buf);
484 g_free(blk);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100485
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100486 block_mig_state.read_done--;
487 block_mig_state.transferred++;
488 assert(block_mig_state.read_done >= 0);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200489 }
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200490
malcd0f2c4c2010-02-07 02:03:50 +0300491 DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__,
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100492 block_mig_state.submitted, block_mig_state.read_done,
493 block_mig_state.transferred);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200494}
495
Liran Schour889ae392010-01-26 10:31:49 +0200496static int64_t get_remaining_dirty(void)
497{
498 BlkMigDevState *bmds;
499 int64_t dirty = 0;
500
501 QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
502 dirty += bdrv_get_dirty_count(bmds->bs);
503 }
504
505 return dirty * BLOCK_SIZE;
506}
507
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200508static int is_stage2_completed(void)
509{
Liran Schour889ae392010-01-26 10:31:49 +0200510 int64_t remaining_dirty;
511 long double bwidth;
512
513 if (block_mig_state.bulk_completed == 1) {
514
515 remaining_dirty = get_remaining_dirty();
Yoshiaki Tamurabd0858b2010-07-26 13:25:41 +0900516 if (remaining_dirty == 0) {
517 return 1;
518 }
Liran Schour889ae392010-01-26 10:31:49 +0200519
Yoshiaki Tamurabd0858b2010-07-26 13:25:41 +0900520 bwidth = compute_read_bwidth();
Liran Schour889ae392010-01-26 10:31:49 +0200521
Yoshiaki Tamurabd0858b2010-07-26 13:25:41 +0900522 if ((remaining_dirty / bwidth) <=
Liran Schour889ae392010-01-26 10:31:49 +0200523 migrate_max_downtime()) {
Stefan Weil4238e262011-11-13 22:24:27 +0100524 /* finish stage2 because we think that we can finish remaining work
Liran Schour889ae392010-01-26 10:31:49 +0200525 below max_downtime */
526
527 return 1;
528 }
529 }
530
531 return 0;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200532}
533
Jan Kiszka71840492009-11-30 18:21:21 +0100534static void blk_mig_cleanup(Monitor *mon)
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +0100535{
Jan Kiszka82801d82009-11-30 18:21:21 +0100536 BlkMigDevState *bmds;
537 BlkMigBlock *blk;
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +0100538
Marcelo Tosatti8f794c52011-01-26 12:12:31 -0200539 set_dirty_tracking(0);
540
Jan Kiszka82801d82009-11-30 18:21:21 +0100541 while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) {
542 QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);
Marcelo Tosatti85916752011-01-26 12:12:35 -0200543 bdrv_set_in_use(bmds->bs, 0);
Marcelo Tosattif48905d2011-01-26 12:12:33 -0200544 drive_put_ref(drive_get_by_blockdev(bmds->bs));
Anthony Liguori7267c092011-08-20 22:09:37 -0500545 g_free(bmds->aio_bitmap);
546 g_free(bmds);
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +0100547 }
548
Jan Kiszka82801d82009-11-30 18:21:21 +0100549 while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
550 QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
Anthony Liguori7267c092011-08-20 22:09:37 -0500551 g_free(blk->buf);
552 g_free(blk);
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +0100553 }
554
Jan Kiszka71840492009-11-30 18:21:21 +0100555 monitor_printf(mon, "\n");
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +0100556}
557
Jan Kiszkaf327aa02009-11-30 18:21:21 +0100558static int block_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200559{
Juan Quintela29757252011-10-19 15:22:18 +0200560 int ret;
561
malcd0f2c4c2010-02-07 02:03:50 +0300562 DPRINTF("Enter save live stage %d submitted %d transferred %d\n",
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100563 stage, block_mig_state.submitted, block_mig_state.transferred);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100564
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +0100565 if (stage < 0) {
Jan Kiszka71840492009-11-30 18:21:21 +0100566 blk_mig_cleanup(mon);
Jan Kiszka4ec7fcc2009-11-30 18:21:21 +0100567 return 0;
568 }
569
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100570 if (block_mig_state.blk_enable != 1) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200571 /* no need to migrate storage */
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100572 qemu_put_be64(f, BLK_MIG_FLAG_EOS);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200573 return 1;
574 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100575
576 if (stage == 1) {
Jan Kiszka71840492009-11-30 18:21:21 +0100577 init_blk_migration(mon, f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100578
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200579 /* start track dirty blocks */
580 set_dirty_tracking(1);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200581 }
582
583 flush_blks(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100584
Juan Quintela29757252011-10-19 15:22:18 +0200585 ret = qemu_file_get_error(f);
586 if (ret) {
Jan Kiszka71840492009-11-30 18:21:21 +0100587 blk_mig_cleanup(mon);
Juan Quintela29757252011-10-19 15:22:18 +0200588 return ret;
Jan Kiszka4b640362009-11-30 18:21:21 +0100589 }
590
Liran Schourd76cac72010-01-26 14:04:11 +0200591 blk_mig_reset_dirty_cursor();
592
Liran Schour889ae392010-01-26 10:31:49 +0200593 if (stage == 2) {
Liran Schourd76cac72010-01-26 14:04:11 +0200594 /* control the rate of transfer */
595 while ((block_mig_state.submitted +
596 block_mig_state.read_done) * BLOCK_SIZE <
597 qemu_file_get_rate_limit(f)) {
598 if (block_mig_state.bulk_completed == 0) {
599 /* first finish the bulk phase */
600 if (blk_mig_save_bulked_block(mon, f) == 0) {
Liran Schour889ae392010-01-26 10:31:49 +0200601 /* finished saving bulk on all devices */
Liran Schourd76cac72010-01-26 14:04:11 +0200602 block_mig_state.bulk_completed = 1;
603 }
604 } else {
605 if (blk_mig_save_dirty_block(mon, f, 1) == 0) {
606 /* no more dirty blocks */
607 break;
608 }
609 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100610 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100611
Liran Schourd76cac72010-01-26 14:04:11 +0200612 flush_blks(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100613
Juan Quintela29757252011-10-19 15:22:18 +0200614 ret = qemu_file_get_error(f);
615 if (ret) {
Liran Schourd76cac72010-01-26 14:04:11 +0200616 blk_mig_cleanup(mon);
Juan Quintela29757252011-10-19 15:22:18 +0200617 return ret;
Liran Schourd76cac72010-01-26 14:04:11 +0200618 }
Jan Kiszka4b640362009-11-30 18:21:21 +0100619 }
620
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100621 if (stage == 3) {
Liran Schour889ae392010-01-26 10:31:49 +0200622 /* we know for sure that save bulk is completed and
623 all async read completed */
624 assert(block_mig_state.submitted == 0);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100625
Liran Schour889ae392010-01-26 10:31:49 +0200626 while (blk_mig_save_dirty_block(mon, f, 0) != 0);
Jan Kiszka71840492009-11-30 18:21:21 +0100627 blk_mig_cleanup(mon);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100628
Jan Kiszka01e61e22009-12-01 15:20:17 +0100629 /* report completion */
630 qemu_put_be64(f, (100 << BDRV_SECTOR_BITS) | BLK_MIG_FLAG_PROGRESS);
631
Juan Quintela29757252011-10-19 15:22:18 +0200632 ret = qemu_file_get_error(f);
633 if (ret) {
634 return ret;
Jan Kiszka4b640362009-11-30 18:21:21 +0100635 }
636
Jan Kiszka71840492009-11-30 18:21:21 +0100637 monitor_printf(mon, "Block migration completed\n");
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200638 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100639
640 qemu_put_be64(f, BLK_MIG_FLAG_EOS);
641
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200642 return ((stage == 2) && is_stage2_completed());
643}
644
645static int block_load(QEMUFile *f, void *opaque, int version_id)
646{
Jan Kiszka01e61e22009-12-01 15:20:17 +0100647 static int banner_printed;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200648 int len, flags;
649 char device_name[256];
650 int64_t addr;
Pierre Riteau77358b52011-01-21 12:42:30 +0100651 BlockDriverState *bs, *bs_prev = NULL;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200652 uint8_t *buf;
Pierre Riteau77358b52011-01-21 12:42:30 +0100653 int64_t total_sectors = 0;
654 int nr_sectors;
Juan Quintela42802d42011-10-05 01:14:46 +0200655 int ret;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100656
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200657 do {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200658 addr = qemu_get_be64(f);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100659
Jan Kiszka6ea44302009-11-30 18:21:19 +0100660 flags = addr & ~BDRV_SECTOR_MASK;
661 addr >>= BDRV_SECTOR_BITS;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100662
663 if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200664 /* get device name */
665 len = qemu_get_byte(f);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200666 qemu_get_buffer(f, (uint8_t *)device_name, len);
667 device_name[len] = '\0';
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100668
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200669 bs = bdrv_find(device_name);
Jan Kiszka4b640362009-11-30 18:21:21 +0100670 if (!bs) {
671 fprintf(stderr, "Error unknown block device %s\n",
672 device_name);
673 return -EINVAL;
674 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100675
Pierre Riteau77358b52011-01-21 12:42:30 +0100676 if (bs != bs_prev) {
677 bs_prev = bs;
678 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
679 if (total_sectors <= 0) {
Markus Armbruster6daf1942011-06-22 14:03:54 +0200680 error_report("Error getting length of block device %s",
Pierre Riteau77358b52011-01-21 12:42:30 +0100681 device_name);
682 return -EINVAL;
683 }
684 }
685
686 if (total_sectors - addr < BDRV_SECTORS_PER_DIRTY_CHUNK) {
687 nr_sectors = total_sectors - addr;
688 } else {
689 nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
690 }
691
Anthony Liguori7267c092011-08-20 22:09:37 -0500692 buf = g_malloc(BLOCK_SIZE);
Jan Kiszka575a58d2009-11-30 18:21:20 +0100693
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100694 qemu_get_buffer(f, buf, BLOCK_SIZE);
Pierre Riteau77358b52011-01-21 12:42:30 +0100695 ret = bdrv_write(bs, addr, buf, nr_sectors);
Jan Kiszka575a58d2009-11-30 18:21:20 +0100696
Anthony Liguori7267c092011-08-20 22:09:37 -0500697 g_free(buf);
Yoshiaki Tamurab02bea32010-07-20 18:19:00 +0900698 if (ret < 0) {
699 return ret;
700 }
Jan Kiszka01e61e22009-12-01 15:20:17 +0100701 } else if (flags & BLK_MIG_FLAG_PROGRESS) {
702 if (!banner_printed) {
703 printf("Receiving block device images\n");
704 banner_printed = 1;
705 }
706 printf("Completed %d %%%c", (int)addr,
707 (addr == 100) ? '\n' : '\r');
708 fflush(stdout);
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100709 } else if (!(flags & BLK_MIG_FLAG_EOS)) {
Jan Kiszka4b640362009-11-30 18:21:21 +0100710 fprintf(stderr, "Unknown flags\n");
711 return -EINVAL;
712 }
Juan Quintela42802d42011-10-05 01:14:46 +0200713 ret = qemu_file_get_error(f);
714 if (ret != 0) {
715 return ret;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200716 }
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100717 } while (!(flags & BLK_MIG_FLAG_EOS));
718
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200719 return 0;
720}
721
722static void block_set_params(int blk_enable, int shared_base, void *opaque)
723{
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100724 block_mig_state.blk_enable = blk_enable;
725 block_mig_state.shared_base = shared_base;
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100726
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200727 /* shared base means that blk_enable = 1 */
Jan Kiszkad11ecd32009-11-30 18:21:20 +0100728 block_mig_state.blk_enable |= shared_base;
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200729}
730
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200731void blk_mig_init(void)
Jan Kiszkaa55eb922009-11-30 18:21:19 +0100732{
Jan Kiszka5e5328b2009-11-30 18:21:20 +0100733 QSIMPLEQ_INIT(&block_mig_state.bmds_list);
734 QSIMPLEQ_INIT(&block_mig_state.blk_list);
735
Alex Williamson0be71e32010-06-25 11:09:07 -0600736 register_savevm_live(NULL, "block", 0, 1, block_set_params,
737 block_save_live, NULL, block_load, &block_mig_state);
lirans@il.ibm.comc163b5c2009-11-02 15:40:58 +0200738}