]>
Commit | Line | Data |
---|---|---|
c163b5ca LS |
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 | * | |
6b620ca3 PB |
12 | * Contributions after 2012-01-13 are licensed under the terms of the |
13 | * GNU GPL, version 2 or (at your option) any later version. | |
c163b5ca LS |
14 | */ |
15 | ||
1393a485 | 16 | #include "qemu/osdep.h" |
da34e65c | 17 | #include "qapi/error.h" |
c163b5ca | 18 | #include "qemu-common.h" |
bfb197e0 MA |
19 | #include "block/block.h" |
20 | #include "qemu/error-report.h" | |
21 | #include "qemu/main-loop.h" | |
c163b5ca | 22 | #include "hw/hw.h" |
f348b6d1 | 23 | #include "qemu/cutils.h" |
1de7afc9 PB |
24 | #include "qemu/queue.h" |
25 | #include "qemu/timer.h" | |
caf71f86 PB |
26 | #include "migration/block.h" |
27 | #include "migration/migration.h" | |
9c17d615 | 28 | #include "sysemu/blockdev.h" |
c9ebaf74 | 29 | #include "sysemu/block-backend.h" |
c163b5ca | 30 | |
50717e94 PB |
31 | #define BLOCK_SIZE (1 << 20) |
32 | #define BDRV_SECTORS_PER_DIRTY_CHUNK (BLOCK_SIZE >> BDRV_SECTOR_BITS) | |
c163b5ca LS |
33 | |
34 | #define BLK_MIG_FLAG_DEVICE_BLOCK 0x01 | |
35 | #define BLK_MIG_FLAG_EOS 0x02 | |
01e61e2d | 36 | #define BLK_MIG_FLAG_PROGRESS 0x04 |
323004a3 | 37 | #define BLK_MIG_FLAG_ZERO_BLOCK 0x08 |
c163b5ca LS |
38 | |
39 | #define MAX_IS_ALLOCATED_SEARCH 65536 | |
c163b5ca | 40 | |
f77dcdbc WC |
41 | #define MAX_INFLIGHT_IO 512 |
42 | ||
c163b5ca LS |
43 | //#define DEBUG_BLK_MIGRATION |
44 | ||
45 | #ifdef DEBUG_BLK_MIGRATION | |
d0f2c4c6 | 46 | #define DPRINTF(fmt, ...) \ |
c163b5ca LS |
47 | do { printf("blk_migration: " fmt, ## __VA_ARGS__); } while (0) |
48 | #else | |
d0f2c4c6 | 49 | #define DPRINTF(fmt, ...) \ |
c163b5ca LS |
50 | do { } while (0) |
51 | #endif | |
52 | ||
a55eb92c | 53 | typedef struct BlkMigDevState { |
323920c4 | 54 | /* Written during setup phase. Can be read without a lock. */ |
ebd2f9e7 KW |
55 | BlockBackend *blk; |
56 | char *blk_name; | |
a55eb92c | 57 | int shared_base; |
a55eb92c | 58 | int64_t total_sectors; |
5e5328be | 59 | QSIMPLEQ_ENTRY(BlkMigDevState) entry; |
ef0716df | 60 | Error *blocker; |
323920c4 PB |
61 | |
62 | /* Only used by migration thread. Does not need a lock. */ | |
63 | int bulk_completed; | |
64 | int64_t cur_sector; | |
65 | int64_t cur_dirty; | |
66 | ||
ef0716df PB |
67 | /* Data in the aio_bitmap is protected by block migration lock. |
68 | * Allocation and free happen during setup and cleanup respectively. | |
69 | */ | |
33656af7 | 70 | unsigned long *aio_bitmap; |
ef0716df PB |
71 | |
72 | /* Protected by block migration lock. */ | |
323920c4 | 73 | int64_t completed_sectors; |
ef0716df PB |
74 | |
75 | /* During migration this is protected by iothread lock / AioContext. | |
76 | * Allocation and free happen during setup and cleanup respectively. | |
77 | */ | |
e4654d2d | 78 | BdrvDirtyBitmap *dirty_bitmap; |
a55eb92c JK |
79 | } BlkMigDevState; |
80 | ||
c163b5ca | 81 | typedef struct BlkMigBlock { |
323920c4 | 82 | /* Only used by migration thread. */ |
c163b5ca LS |
83 | uint8_t *buf; |
84 | BlkMigDevState *bmds; | |
85 | int64_t sector; | |
33656af7 | 86 | int nr_sectors; |
c163b5ca LS |
87 | struct iovec iov; |
88 | QEMUIOVector qiov; | |
7c84b1b8 | 89 | BlockAIOCB *aiocb; |
323920c4 | 90 | |
52e850de | 91 | /* Protected by block migration lock. */ |
c163b5ca | 92 | int ret; |
5e5328be | 93 | QSIMPLEQ_ENTRY(BlkMigBlock) entry; |
c163b5ca LS |
94 | } BlkMigBlock; |
95 | ||
96 | typedef struct BlkMigState { | |
323920c4 | 97 | /* Written during setup phase. Can be read without a lock. */ |
c163b5ca LS |
98 | int blk_enable; |
99 | int shared_base; | |
5e5328be | 100 | QSIMPLEQ_HEAD(bmds_list, BlkMigDevState) bmds_list; |
323920c4 | 101 | int64_t total_sector_sum; |
323004a3 | 102 | bool zero_blocks; |
323920c4 | 103 | |
52e850de | 104 | /* Protected by lock. */ |
5e5328be | 105 | QSIMPLEQ_HEAD(blk_list, BlkMigBlock) blk_list; |
c163b5ca LS |
106 | int submitted; |
107 | int read_done; | |
323920c4 PB |
108 | |
109 | /* Only used by migration thread. Does not need a lock. */ | |
c163b5ca | 110 | int transferred; |
01e61e2d | 111 | int prev_progress; |
e970ec0b | 112 | int bulk_completed; |
52e850de | 113 | |
ef0716df | 114 | /* Lock must be taken _inside_ the iothread lock and any AioContexts. */ |
52e850de | 115 | QemuMutex lock; |
c163b5ca LS |
116 | } BlkMigState; |
117 | ||
d11ecd3d | 118 | static BlkMigState block_mig_state; |
c163b5ca | 119 | |
52e850de PB |
120 | static void blk_mig_lock(void) |
121 | { | |
122 | qemu_mutex_lock(&block_mig_state.lock); | |
123 | } | |
124 | ||
125 | static void blk_mig_unlock(void) | |
126 | { | |
127 | qemu_mutex_unlock(&block_mig_state.lock); | |
128 | } | |
129 | ||
32c835ba PB |
130 | /* Must run outside of the iothread lock during the bulk phase, |
131 | * or the VM will stall. | |
132 | */ | |
133 | ||
13f0b67f JK |
134 | static void blk_send(QEMUFile *f, BlkMigBlock * blk) |
135 | { | |
136 | int len; | |
323004a3 PL |
137 | uint64_t flags = BLK_MIG_FLAG_DEVICE_BLOCK; |
138 | ||
139 | if (block_mig_state.zero_blocks && | |
140 | buffer_is_zero(blk->buf, BLOCK_SIZE)) { | |
141 | flags |= BLK_MIG_FLAG_ZERO_BLOCK; | |
142 | } | |
13f0b67f JK |
143 | |
144 | /* sector number and flags */ | |
145 | qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS) | |
323004a3 | 146 | | flags); |
13f0b67f JK |
147 | |
148 | /* device name */ | |
ebd2f9e7 | 149 | len = strlen(blk->bmds->blk_name); |
13f0b67f | 150 | qemu_put_byte(f, len); |
ebd2f9e7 | 151 | qemu_put_buffer(f, (uint8_t *) blk->bmds->blk_name, len); |
13f0b67f | 152 | |
323004a3 PL |
153 | /* if a block is zero we need to flush here since the network |
154 | * bandwidth is now a lot higher than the storage device bandwidth. | |
155 | * thus if we queue zero blocks we slow down the migration */ | |
156 | if (flags & BLK_MIG_FLAG_ZERO_BLOCK) { | |
157 | qemu_fflush(f); | |
158 | return; | |
159 | } | |
160 | ||
13f0b67f JK |
161 | qemu_put_buffer(f, blk->buf, BLOCK_SIZE); |
162 | } | |
163 | ||
25f23643 JK |
164 | int blk_mig_active(void) |
165 | { | |
166 | return !QSIMPLEQ_EMPTY(&block_mig_state.bmds_list); | |
167 | } | |
168 | ||
169 | uint64_t blk_mig_bytes_transferred(void) | |
170 | { | |
171 | BlkMigDevState *bmds; | |
172 | uint64_t sum = 0; | |
173 | ||
52e850de | 174 | blk_mig_lock(); |
25f23643 JK |
175 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { |
176 | sum += bmds->completed_sectors; | |
177 | } | |
52e850de | 178 | blk_mig_unlock(); |
25f23643 JK |
179 | return sum << BDRV_SECTOR_BITS; |
180 | } | |
181 | ||
182 | uint64_t blk_mig_bytes_remaining(void) | |
183 | { | |
184 | return blk_mig_bytes_total() - blk_mig_bytes_transferred(); | |
185 | } | |
186 | ||
187 | uint64_t blk_mig_bytes_total(void) | |
188 | { | |
189 | BlkMigDevState *bmds; | |
190 | uint64_t sum = 0; | |
191 | ||
192 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { | |
193 | sum += bmds->total_sectors; | |
194 | } | |
195 | return sum << BDRV_SECTOR_BITS; | |
196 | } | |
197 | ||
52e850de PB |
198 | |
199 | /* Called with migration lock held. */ | |
200 | ||
33656af7 MT |
201 | static int bmds_aio_inflight(BlkMigDevState *bmds, int64_t sector) |
202 | { | |
203 | int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK; | |
204 | ||
ebd2f9e7 | 205 | if (sector < blk_nb_sectors(bmds->blk)) { |
33656af7 MT |
206 | return !!(bmds->aio_bitmap[chunk / (sizeof(unsigned long) * 8)] & |
207 | (1UL << (chunk % (sizeof(unsigned long) * 8)))); | |
208 | } else { | |
209 | return 0; | |
210 | } | |
211 | } | |
212 | ||
52e850de PB |
213 | /* Called with migration lock held. */ |
214 | ||
33656af7 MT |
215 | static void bmds_set_aio_inflight(BlkMigDevState *bmds, int64_t sector_num, |
216 | int nb_sectors, int set) | |
217 | { | |
218 | int64_t start, end; | |
219 | unsigned long val, idx, bit; | |
220 | ||
221 | start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK; | |
222 | end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK; | |
223 | ||
224 | for (; start <= end; start++) { | |
225 | idx = start / (sizeof(unsigned long) * 8); | |
226 | bit = start % (sizeof(unsigned long) * 8); | |
227 | val = bmds->aio_bitmap[idx]; | |
228 | if (set) { | |
62155e2b | 229 | val |= 1UL << bit; |
33656af7 | 230 | } else { |
62155e2b | 231 | val &= ~(1UL << bit); |
33656af7 MT |
232 | } |
233 | bmds->aio_bitmap[idx] = val; | |
234 | } | |
235 | } | |
236 | ||
237 | static void alloc_aio_bitmap(BlkMigDevState *bmds) | |
238 | { | |
ebd2f9e7 | 239 | BlockBackend *bb = bmds->blk; |
33656af7 MT |
240 | int64_t bitmap_size; |
241 | ||
ebd2f9e7 | 242 | bitmap_size = blk_nb_sectors(bb) + BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1; |
33656af7 MT |
243 | bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8; |
244 | ||
7267c094 | 245 | bmds->aio_bitmap = g_malloc0(bitmap_size); |
33656af7 MT |
246 | } |
247 | ||
52e850de PB |
248 | /* Never hold migration lock when yielding to the main loop! */ |
249 | ||
c163b5ca LS |
250 | static void blk_mig_read_cb(void *opaque, int ret) |
251 | { | |
252 | BlkMigBlock *blk = opaque; | |
a55eb92c | 253 | |
52e850de | 254 | blk_mig_lock(); |
c163b5ca | 255 | blk->ret = ret; |
a55eb92c | 256 | |
5e5328be | 257 | QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry); |
33656af7 | 258 | bmds_set_aio_inflight(blk->bmds, blk->sector, blk->nr_sectors, 0); |
a55eb92c | 259 | |
d11ecd3d JK |
260 | block_mig_state.submitted--; |
261 | block_mig_state.read_done++; | |
262 | assert(block_mig_state.submitted >= 0); | |
52e850de | 263 | blk_mig_unlock(); |
c163b5ca LS |
264 | } |
265 | ||
32c835ba PB |
266 | /* Called with no lock taken. */ |
267 | ||
539de124 | 268 | static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds) |
a55eb92c | 269 | { |
57cce12d JK |
270 | int64_t total_sectors = bmds->total_sectors; |
271 | int64_t cur_sector = bmds->cur_sector; | |
ebd2f9e7 | 272 | BlockBackend *bb = bmds->blk; |
c163b5ca | 273 | BlkMigBlock *blk; |
13f0b67f | 274 | int nr_sectors; |
a55eb92c | 275 | |
57cce12d | 276 | if (bmds->shared_base) { |
32c835ba | 277 | qemu_mutex_lock_iothread(); |
ebd2f9e7 | 278 | aio_context_acquire(blk_get_aio_context(bb)); |
b1d10856 | 279 | while (cur_sector < total_sectors && |
ebd2f9e7 KW |
280 | !bdrv_is_allocated(blk_bs(bb), cur_sector, |
281 | MAX_IS_ALLOCATED_SEARCH, &nr_sectors)) { | |
c163b5ca LS |
282 | cur_sector += nr_sectors; |
283 | } | |
ebd2f9e7 | 284 | aio_context_release(blk_get_aio_context(bb)); |
32c835ba | 285 | qemu_mutex_unlock_iothread(); |
c163b5ca | 286 | } |
a55eb92c JK |
287 | |
288 | if (cur_sector >= total_sectors) { | |
82801d8f | 289 | bmds->cur_sector = bmds->completed_sectors = total_sectors; |
c163b5ca LS |
290 | return 1; |
291 | } | |
a55eb92c | 292 | |
82801d8f | 293 | bmds->completed_sectors = cur_sector; |
a55eb92c | 294 | |
57cce12d JK |
295 | cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1); |
296 | ||
6ea44308 JK |
297 | /* we are going to transfer a full block even if it is not allocated */ |
298 | nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK; | |
c163b5ca | 299 | |
6ea44308 | 300 | if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) { |
57cce12d | 301 | nr_sectors = total_sectors - cur_sector; |
c163b5ca | 302 | } |
a55eb92c | 303 | |
5839e53b | 304 | blk = g_new(BlkMigBlock, 1); |
7267c094 | 305 | blk->buf = g_malloc(BLOCK_SIZE); |
13f0b67f JK |
306 | blk->bmds = bmds; |
307 | blk->sector = cur_sector; | |
33656af7 | 308 | blk->nr_sectors = nr_sectors; |
a55eb92c | 309 | |
e970ec0b LS |
310 | blk->iov.iov_base = blk->buf; |
311 | blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE; | |
312 | qemu_iovec_init_external(&blk->qiov, &blk->iov, 1); | |
a55eb92c | 313 | |
52e850de | 314 | blk_mig_lock(); |
13197e3c | 315 | block_mig_state.submitted++; |
52e850de | 316 | blk_mig_unlock(); |
13197e3c | 317 | |
ef0716df PB |
318 | /* We do not know if bs is under the main thread (and thus does |
319 | * not acquire the AioContext when doing AIO) or rather under | |
320 | * dataplane. Thus acquire both the iothread mutex and the | |
321 | * AioContext. | |
322 | * | |
323 | * This is ugly and will disappear when we make bdrv_* thread-safe, | |
324 | * without the need to acquire the AioContext. | |
325 | */ | |
32c835ba | 326 | qemu_mutex_lock_iothread(); |
ebd2f9e7 KW |
327 | aio_context_acquire(blk_get_aio_context(bmds->blk)); |
328 | blk->aiocb = blk_aio_preadv(bb, cur_sector * BDRV_SECTOR_SIZE, &blk->qiov, | |
329 | 0, blk_mig_read_cb, blk); | |
d76cac7d | 330 | |
20dca810 | 331 | bdrv_reset_dirty_bitmap(bmds->dirty_bitmap, cur_sector, nr_sectors); |
ebd2f9e7 | 332 | aio_context_release(blk_get_aio_context(bmds->blk)); |
32c835ba | 333 | qemu_mutex_unlock_iothread(); |
a55eb92c | 334 | |
32c835ba | 335 | bmds->cur_sector = cur_sector + nr_sectors; |
13f0b67f | 336 | return (bmds->cur_sector >= total_sectors); |
c163b5ca LS |
337 | } |
338 | ||
32c835ba PB |
339 | /* Called with iothread lock taken. */ |
340 | ||
b8afb520 | 341 | static int set_dirty_tracking(void) |
c163b5ca LS |
342 | { |
343 | BlkMigDevState *bmds; | |
b8afb520 FZ |
344 | int ret; |
345 | ||
346 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { | |
ebd2f9e7 KW |
347 | aio_context_acquire(blk_get_aio_context(bmds->blk)); |
348 | bmds->dirty_bitmap = bdrv_create_dirty_bitmap(blk_bs(bmds->blk), | |
349 | BLOCK_SIZE, NULL, NULL); | |
350 | aio_context_release(blk_get_aio_context(bmds->blk)); | |
b8afb520 FZ |
351 | if (!bmds->dirty_bitmap) { |
352 | ret = -errno; | |
353 | goto fail; | |
354 | } | |
355 | } | |
356 | return 0; | |
5e5328be | 357 | |
b8afb520 | 358 | fail: |
5e5328be | 359 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { |
b8afb520 | 360 | if (bmds->dirty_bitmap) { |
ebd2f9e7 KW |
361 | aio_context_acquire(blk_get_aio_context(bmds->blk)); |
362 | bdrv_release_dirty_bitmap(blk_bs(bmds->blk), bmds->dirty_bitmap); | |
363 | aio_context_release(blk_get_aio_context(bmds->blk)); | |
b8afb520 | 364 | } |
e4654d2d | 365 | } |
b8afb520 | 366 | return ret; |
e4654d2d FZ |
367 | } |
368 | ||
ef0716df PB |
369 | /* Called with iothread lock taken. */ |
370 | ||
e4654d2d FZ |
371 | static void unset_dirty_tracking(void) |
372 | { | |
373 | BlkMigDevState *bmds; | |
374 | ||
375 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { | |
ebd2f9e7 KW |
376 | aio_context_acquire(blk_get_aio_context(bmds->blk)); |
377 | bdrv_release_dirty_bitmap(blk_bs(bmds->blk), bmds->dirty_bitmap); | |
378 | aio_context_release(blk_get_aio_context(bmds->blk)); | |
c163b5ca | 379 | } |
c163b5ca LS |
380 | } |
381 | ||
6f5ef23a | 382 | static int init_blk_migration(QEMUFile *f) |
c163b5ca | 383 | { |
fea68bb6 | 384 | BlockDriverState *bs; |
5e5328be | 385 | BlkMigDevState *bmds; |
792773b2 | 386 | int64_t sectors; |
88be7b4b | 387 | BdrvNextIterator it; |
ebd2f9e7 KW |
388 | int i, num_bs = 0; |
389 | struct { | |
390 | BlkMigDevState *bmds; | |
391 | BlockDriverState *bs; | |
392 | } *bmds_bs; | |
6f5ef23a KW |
393 | Error *local_err = NULL; |
394 | int ret; | |
a55eb92c | 395 | |
fea68bb6 MA |
396 | block_mig_state.submitted = 0; |
397 | block_mig_state.read_done = 0; | |
398 | block_mig_state.transferred = 0; | |
399 | block_mig_state.total_sector_sum = 0; | |
400 | block_mig_state.prev_progress = -1; | |
401 | block_mig_state.bulk_completed = 0; | |
402 | block_mig_state.zero_blocks = migrate_zero_blocks(); | |
403 | ||
88be7b4b | 404 | for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { |
ebd2f9e7 KW |
405 | num_bs++; |
406 | } | |
407 | bmds_bs = g_malloc0(num_bs * sizeof(*bmds_bs)); | |
408 | ||
409 | for (i = 0, bs = bdrv_first(&it); bs; bs = bdrv_next(&it), i++) { | |
fea68bb6 MA |
410 | if (bdrv_is_read_only(bs)) { |
411 | continue; | |
412 | } | |
413 | ||
57322b78 | 414 | sectors = bdrv_nb_sectors(bs); |
31f54f24 | 415 | if (sectors <= 0) { |
6f5ef23a | 416 | ret = sectors; |
ebd2f9e7 | 417 | goto out; |
b66460e4 SH |
418 | } |
419 | ||
5839e53b | 420 | bmds = g_new0(BlkMigDevState, 1); |
6f5ef23a | 421 | bmds->blk = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL); |
ebd2f9e7 | 422 | bmds->blk_name = g_strdup(bdrv_get_device_name(bs)); |
b66460e4 SH |
423 | bmds->bulk_completed = 0; |
424 | bmds->total_sectors = sectors; | |
425 | bmds->completed_sectors = 0; | |
426 | bmds->shared_base = block_mig_state.shared_base; | |
ebd2f9e7 KW |
427 | |
428 | assert(i < num_bs); | |
429 | bmds_bs[i].bmds = bmds; | |
430 | bmds_bs[i].bs = bs; | |
b66460e4 SH |
431 | |
432 | block_mig_state.total_sector_sum += sectors; | |
433 | ||
434 | if (bmds->shared_base) { | |
539de124 | 435 | DPRINTF("Start migration for %s with shared base image\n", |
bfb197e0 | 436 | bdrv_get_device_name(bs)); |
b66460e4 | 437 | } else { |
bfb197e0 | 438 | DPRINTF("Start full migration for %s\n", bdrv_get_device_name(bs)); |
b66460e4 SH |
439 | } |
440 | ||
441 | QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry); | |
442 | } | |
ebd2f9e7 KW |
443 | |
444 | /* Can only insert new BDSes now because doing so while iterating block | |
445 | * devices may end up in a deadlock (iterating the new BDSes, too). */ | |
446 | for (i = 0; i < num_bs; i++) { | |
447 | BlkMigDevState *bmds = bmds_bs[i].bmds; | |
448 | BlockDriverState *bs = bmds_bs[i].bs; | |
449 | ||
450 | if (bmds) { | |
6f5ef23a KW |
451 | ret = blk_insert_bs(bmds->blk, bs, &local_err); |
452 | if (ret < 0) { | |
453 | error_report_err(local_err); | |
454 | goto out; | |
455 | } | |
ebd2f9e7 KW |
456 | |
457 | alloc_aio_bitmap(bmds); | |
458 | error_setg(&bmds->blocker, "block device is in use by migration"); | |
459 | bdrv_op_block_all(bs, bmds->blocker); | |
460 | } | |
461 | } | |
462 | ||
6f5ef23a | 463 | ret = 0; |
ebd2f9e7 KW |
464 | out: |
465 | g_free(bmds_bs); | |
6f5ef23a | 466 | return ret; |
b66460e4 SH |
467 | } |
468 | ||
32c835ba PB |
469 | /* Called with no lock taken. */ |
470 | ||
539de124 | 471 | static int blk_mig_save_bulked_block(QEMUFile *f) |
c163b5ca | 472 | { |
82801d8f | 473 | int64_t completed_sector_sum = 0; |
c163b5ca | 474 | BlkMigDevState *bmds; |
01e61e2d | 475 | int progress; |
82801d8f | 476 | int ret = 0; |
c163b5ca | 477 | |
5e5328be | 478 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { |
a55eb92c | 479 | if (bmds->bulk_completed == 0) { |
539de124 | 480 | if (mig_save_device_bulk(f, bmds) == 1) { |
57cce12d JK |
481 | /* completed bulk section for this device */ |
482 | bmds->bulk_completed = 1; | |
c163b5ca | 483 | } |
82801d8f JK |
484 | completed_sector_sum += bmds->completed_sectors; |
485 | ret = 1; | |
486 | break; | |
487 | } else { | |
488 | completed_sector_sum += bmds->completed_sectors; | |
c163b5ca LS |
489 | } |
490 | } | |
a55eb92c | 491 | |
8b6b2afc PR |
492 | if (block_mig_state.total_sector_sum != 0) { |
493 | progress = completed_sector_sum * 100 / | |
494 | block_mig_state.total_sector_sum; | |
495 | } else { | |
496 | progress = 100; | |
497 | } | |
01e61e2d JK |
498 | if (progress != block_mig_state.prev_progress) { |
499 | block_mig_state.prev_progress = progress; | |
500 | qemu_put_be64(f, (progress << BDRV_SECTOR_BITS) | |
501 | | BLK_MIG_FLAG_PROGRESS); | |
539de124 | 502 | DPRINTF("Completed %d %%\r", progress); |
82801d8f JK |
503 | } |
504 | ||
505 | return ret; | |
c163b5ca LS |
506 | } |
507 | ||
d76cac7d | 508 | static void blk_mig_reset_dirty_cursor(void) |
c163b5ca LS |
509 | { |
510 | BlkMigDevState *bmds; | |
d76cac7d LS |
511 | |
512 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { | |
513 | bmds->cur_dirty = 0; | |
514 | } | |
515 | } | |
516 | ||
ef0716df | 517 | /* Called with iothread lock and AioContext taken. */ |
32c835ba | 518 | |
539de124 LC |
519 | static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds, |
520 | int is_async) | |
d76cac7d LS |
521 | { |
522 | BlkMigBlock *blk; | |
ebd2f9e7 | 523 | BlockDriverState *bs = blk_bs(bmds->blk); |
d76cac7d | 524 | int64_t total_sectors = bmds->total_sectors; |
c163b5ca | 525 | int64_t sector; |
d76cac7d | 526 | int nr_sectors; |
dcd1d224 | 527 | int ret = -EIO; |
a55eb92c | 528 | |
d76cac7d | 529 | for (sector = bmds->cur_dirty; sector < bmds->total_sectors;) { |
52e850de | 530 | blk_mig_lock(); |
62155e2b | 531 | if (bmds_aio_inflight(bmds, sector)) { |
52e850de | 532 | blk_mig_unlock(); |
ebd2f9e7 | 533 | blk_drain(bmds->blk); |
52e850de PB |
534 | } else { |
535 | blk_mig_unlock(); | |
62155e2b | 536 | } |
ebd2f9e7 | 537 | if (bdrv_get_dirty(bs, bmds->dirty_bitmap, sector)) { |
575a58d7 | 538 | |
d76cac7d LS |
539 | if (total_sectors - sector < BDRV_SECTORS_PER_DIRTY_CHUNK) { |
540 | nr_sectors = total_sectors - sector; | |
541 | } else { | |
542 | nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK; | |
543 | } | |
5839e53b | 544 | blk = g_new(BlkMigBlock, 1); |
7267c094 | 545 | blk->buf = g_malloc(BLOCK_SIZE); |
d76cac7d LS |
546 | blk->bmds = bmds; |
547 | blk->sector = sector; | |
33656af7 | 548 | blk->nr_sectors = nr_sectors; |
d76cac7d | 549 | |
889ae39c | 550 | if (is_async) { |
d76cac7d LS |
551 | blk->iov.iov_base = blk->buf; |
552 | blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE; | |
553 | qemu_iovec_init_external(&blk->qiov, &blk->iov, 1); | |
554 | ||
ebd2f9e7 KW |
555 | blk->aiocb = blk_aio_preadv(bmds->blk, |
556 | sector * BDRV_SECTOR_SIZE, | |
557 | &blk->qiov, 0, blk_mig_read_cb, | |
558 | blk); | |
52e850de PB |
559 | |
560 | blk_mig_lock(); | |
d76cac7d | 561 | block_mig_state.submitted++; |
33656af7 | 562 | bmds_set_aio_inflight(bmds, sector, nr_sectors, 1); |
52e850de | 563 | blk_mig_unlock(); |
d76cac7d | 564 | } else { |
ebd2f9e7 KW |
565 | ret = blk_pread(bmds->blk, sector * BDRV_SECTOR_SIZE, blk->buf, |
566 | nr_sectors * BDRV_SECTOR_SIZE); | |
dcd1d224 | 567 | if (ret < 0) { |
d76cac7d | 568 | goto error; |
c163b5ca | 569 | } |
d76cac7d | 570 | blk_send(f, blk); |
a55eb92c | 571 | |
7267c094 AL |
572 | g_free(blk->buf); |
573 | g_free(blk); | |
a55eb92c | 574 | } |
d76cac7d | 575 | |
20dca810 | 576 | bdrv_reset_dirty_bitmap(bmds->dirty_bitmap, sector, nr_sectors); |
d76cac7d | 577 | break; |
c163b5ca | 578 | } |
d76cac7d LS |
579 | sector += BDRV_SECTORS_PER_DIRTY_CHUNK; |
580 | bmds->cur_dirty = sector; | |
c163b5ca | 581 | } |
575a58d7 | 582 | |
d76cac7d LS |
583 | return (bmds->cur_dirty >= bmds->total_sectors); |
584 | ||
889ae39c | 585 | error: |
539de124 | 586 | DPRINTF("Error reading sector %" PRId64 "\n", sector); |
7267c094 AL |
587 | g_free(blk->buf); |
588 | g_free(blk); | |
43be3a25 | 589 | return ret; |
d76cac7d LS |
590 | } |
591 | ||
32c835ba PB |
592 | /* Called with iothread lock taken. |
593 | * | |
594 | * return value: | |
ceb2bd09 JQ |
595 | * 0: too much data for max_downtime |
596 | * 1: few enough data for max_downtime | |
597 | */ | |
539de124 | 598 | static int blk_mig_save_dirty_block(QEMUFile *f, int is_async) |
d76cac7d LS |
599 | { |
600 | BlkMigDevState *bmds; | |
ceb2bd09 | 601 | int ret = 1; |
d76cac7d LS |
602 | |
603 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { | |
ebd2f9e7 | 604 | aio_context_acquire(blk_get_aio_context(bmds->blk)); |
ceb2bd09 | 605 | ret = mig_save_device_dirty(f, bmds, is_async); |
ebd2f9e7 | 606 | aio_context_release(blk_get_aio_context(bmds->blk)); |
43be3a25 | 607 | if (ret <= 0) { |
d76cac7d LS |
608 | break; |
609 | } | |
610 | } | |
611 | ||
612 | return ret; | |
c163b5ca LS |
613 | } |
614 | ||
32c835ba PB |
615 | /* Called with no locks taken. */ |
616 | ||
59feec42 | 617 | static int flush_blks(QEMUFile *f) |
c163b5ca | 618 | { |
5e5328be | 619 | BlkMigBlock *blk; |
59feec42 | 620 | int ret = 0; |
a55eb92c | 621 | |
d0f2c4c6 | 622 | DPRINTF("%s Enter submitted %d read_done %d transferred %d\n", |
d11ecd3d JK |
623 | __FUNCTION__, block_mig_state.submitted, block_mig_state.read_done, |
624 | block_mig_state.transferred); | |
a55eb92c | 625 | |
52e850de | 626 | blk_mig_lock(); |
5e5328be JK |
627 | while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) { |
628 | if (qemu_file_rate_limit(f)) { | |
629 | break; | |
630 | } | |
4b640365 | 631 | if (blk->ret < 0) { |
59feec42 | 632 | ret = blk->ret; |
4b640365 JK |
633 | break; |
634 | } | |
a55eb92c | 635 | |
5e5328be | 636 | QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry); |
52e850de | 637 | blk_mig_unlock(); |
13197e3c | 638 | blk_send(f, blk); |
52e850de | 639 | blk_mig_lock(); |
13197e3c | 640 | |
7267c094 AL |
641 | g_free(blk->buf); |
642 | g_free(blk); | |
a55eb92c | 643 | |
d11ecd3d JK |
644 | block_mig_state.read_done--; |
645 | block_mig_state.transferred++; | |
646 | assert(block_mig_state.read_done >= 0); | |
c163b5ca | 647 | } |
52e850de | 648 | blk_mig_unlock(); |
c163b5ca | 649 | |
d0f2c4c6 | 650 | DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__, |
d11ecd3d JK |
651 | block_mig_state.submitted, block_mig_state.read_done, |
652 | block_mig_state.transferred); | |
59feec42 | 653 | return ret; |
c163b5ca LS |
654 | } |
655 | ||
32c835ba PB |
656 | /* Called with iothread lock taken. */ |
657 | ||
889ae39c LS |
658 | static int64_t get_remaining_dirty(void) |
659 | { | |
660 | BlkMigDevState *bmds; | |
661 | int64_t dirty = 0; | |
662 | ||
663 | QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { | |
ebd2f9e7 | 664 | aio_context_acquire(blk_get_aio_context(bmds->blk)); |
20dca810 | 665 | dirty += bdrv_get_dirty_count(bmds->dirty_bitmap); |
ebd2f9e7 | 666 | aio_context_release(blk_get_aio_context(bmds->blk)); |
889ae39c LS |
667 | } |
668 | ||
acc906c6 | 669 | return dirty << BDRV_SECTOR_BITS; |
889ae39c LS |
670 | } |
671 | ||
32c835ba PB |
672 | /* Called with iothread lock taken. */ |
673 | ||
6ad2a215 | 674 | static void block_migration_cleanup(void *opaque) |
4ec7fcc7 | 675 | { |
82801d8f JK |
676 | BlkMigDevState *bmds; |
677 | BlkMigBlock *blk; | |
ef0716df | 678 | AioContext *ctx; |
4ec7fcc7 | 679 | |
946d58be KW |
680 | bdrv_drain_all(); |
681 | ||
e4654d2d | 682 | unset_dirty_tracking(); |
8f794c55 | 683 | |
82801d8f JK |
684 | while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) { |
685 | QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry); | |
ebd2f9e7 | 686 | bdrv_op_unblock_all(blk_bs(bmds->blk), bmds->blocker); |
3718d8ab | 687 | error_free(bmds->blocker); |
ef0716df | 688 | |
ebd2f9e7 KW |
689 | /* Save ctx, because bmds->blk can disappear during blk_unref. */ |
690 | ctx = blk_get_aio_context(bmds->blk); | |
ef0716df | 691 | aio_context_acquire(ctx); |
ebd2f9e7 | 692 | blk_unref(bmds->blk); |
ef0716df PB |
693 | aio_context_release(ctx); |
694 | ||
ebd2f9e7 | 695 | g_free(bmds->blk_name); |
7267c094 AL |
696 | g_free(bmds->aio_bitmap); |
697 | g_free(bmds); | |
4ec7fcc7 JK |
698 | } |
699 | ||
ef0716df | 700 | blk_mig_lock(); |
82801d8f JK |
701 | while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) { |
702 | QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry); | |
7267c094 AL |
703 | g_free(blk->buf); |
704 | g_free(blk); | |
4ec7fcc7 | 705 | } |
52e850de | 706 | blk_mig_unlock(); |
4ec7fcc7 JK |
707 | } |
708 | ||
d1315aac | 709 | static int block_save_setup(QEMUFile *f, void *opaque) |
c163b5ca | 710 | { |
2975725f JQ |
711 | int ret; |
712 | ||
d1315aac JQ |
713 | DPRINTF("Enter save live setup submitted %d transferred %d\n", |
714 | block_mig_state.submitted, block_mig_state.transferred); | |
a55eb92c | 715 | |
9b095037 | 716 | qemu_mutex_lock_iothread(); |
6f5ef23a KW |
717 | ret = init_blk_migration(f); |
718 | if (ret < 0) { | |
719 | qemu_mutex_unlock_iothread(); | |
720 | return ret; | |
721 | } | |
d1315aac JQ |
722 | |
723 | /* start track dirty blocks */ | |
b8afb520 FZ |
724 | ret = set_dirty_tracking(); |
725 | ||
ef0716df PB |
726 | qemu_mutex_unlock_iothread(); |
727 | ||
b8afb520 | 728 | if (ret) { |
b8afb520 FZ |
729 | return ret; |
730 | } | |
731 | ||
59feec42 | 732 | ret = flush_blks(f); |
d1315aac | 733 | blk_mig_reset_dirty_cursor(); |
d1315aac JQ |
734 | qemu_put_be64(f, BLK_MIG_FLAG_EOS); |
735 | ||
d418cf57 | 736 | return ret; |
d1315aac JQ |
737 | } |
738 | ||
16310a3c | 739 | static int block_save_iterate(QEMUFile *f, void *opaque) |
d1315aac JQ |
740 | { |
741 | int ret; | |
6aaa9dae | 742 | int64_t last_ftell = qemu_ftell(f); |
ebd9fbd7 | 743 | int64_t delta_ftell; |
d1315aac | 744 | |
16310a3c JQ |
745 | DPRINTF("Enter save live iterate submitted %d transferred %d\n", |
746 | block_mig_state.submitted, block_mig_state.transferred); | |
d1315aac | 747 | |
59feec42 | 748 | ret = flush_blks(f); |
2975725f | 749 | if (ret) { |
2975725f | 750 | return ret; |
4b640365 JK |
751 | } |
752 | ||
d76cac7d LS |
753 | blk_mig_reset_dirty_cursor(); |
754 | ||
16310a3c | 755 | /* control the rate of transfer */ |
52e850de | 756 | blk_mig_lock(); |
16310a3c JQ |
757 | while ((block_mig_state.submitted + |
758 | block_mig_state.read_done) * BLOCK_SIZE < | |
f77dcdbc WC |
759 | qemu_file_get_rate_limit(f) && |
760 | (block_mig_state.submitted + | |
761 | block_mig_state.read_done) < | |
762 | MAX_INFLIGHT_IO) { | |
52e850de | 763 | blk_mig_unlock(); |
16310a3c JQ |
764 | if (block_mig_state.bulk_completed == 0) { |
765 | /* first finish the bulk phase */ | |
766 | if (blk_mig_save_bulked_block(f) == 0) { | |
767 | /* finished saving bulk on all devices */ | |
768 | block_mig_state.bulk_completed = 1; | |
769 | } | |
13197e3c | 770 | ret = 0; |
16310a3c | 771 | } else { |
32c835ba PB |
772 | /* Always called with iothread lock taken for |
773 | * simplicity, block_save_complete also calls it. | |
774 | */ | |
775 | qemu_mutex_lock_iothread(); | |
43be3a25 | 776 | ret = blk_mig_save_dirty_block(f, 1); |
32c835ba | 777 | qemu_mutex_unlock_iothread(); |
13197e3c PB |
778 | } |
779 | if (ret < 0) { | |
780 | return ret; | |
781 | } | |
52e850de | 782 | blk_mig_lock(); |
13197e3c PB |
783 | if (ret != 0) { |
784 | /* no more dirty blocks */ | |
785 | break; | |
a55eb92c | 786 | } |
16310a3c | 787 | } |
52e850de | 788 | blk_mig_unlock(); |
a55eb92c | 789 | |
59feec42 | 790 | ret = flush_blks(f); |
16310a3c | 791 | if (ret) { |
16310a3c | 792 | return ret; |
4b640365 JK |
793 | } |
794 | ||
16310a3c | 795 | qemu_put_be64(f, BLK_MIG_FLAG_EOS); |
ebd9fbd7 GH |
796 | delta_ftell = qemu_ftell(f) - last_ftell; |
797 | if (delta_ftell > 0) { | |
798 | return 1; | |
799 | } else if (delta_ftell < 0) { | |
800 | return -1; | |
801 | } else { | |
802 | return 0; | |
803 | } | |
16310a3c JQ |
804 | } |
805 | ||
32c835ba PB |
806 | /* Called with iothread lock taken. */ |
807 | ||
16310a3c JQ |
808 | static int block_save_complete(QEMUFile *f, void *opaque) |
809 | { | |
810 | int ret; | |
811 | ||
812 | DPRINTF("Enter save live complete submitted %d transferred %d\n", | |
813 | block_mig_state.submitted, block_mig_state.transferred); | |
814 | ||
59feec42 | 815 | ret = flush_blks(f); |
16310a3c | 816 | if (ret) { |
16310a3c JQ |
817 | return ret; |
818 | } | |
a55eb92c | 819 | |
16310a3c | 820 | blk_mig_reset_dirty_cursor(); |
01e61e2d | 821 | |
16310a3c JQ |
822 | /* we know for sure that save bulk is completed and |
823 | all async read completed */ | |
52e850de | 824 | blk_mig_lock(); |
16310a3c | 825 | assert(block_mig_state.submitted == 0); |
52e850de | 826 | blk_mig_unlock(); |
16310a3c | 827 | |
43be3a25 JQ |
828 | do { |
829 | ret = blk_mig_save_dirty_block(f, 0); | |
d418cf57 PB |
830 | if (ret < 0) { |
831 | return ret; | |
832 | } | |
43be3a25 | 833 | } while (ret == 0); |
4b640365 | 834 | |
43be3a25 JQ |
835 | /* report completion */ |
836 | qemu_put_be64(f, (100 << BDRV_SECTOR_BITS) | BLK_MIG_FLAG_PROGRESS); | |
a55eb92c | 837 | |
16310a3c JQ |
838 | DPRINTF("Block migration completed\n"); |
839 | ||
a55eb92c JK |
840 | qemu_put_be64(f, BLK_MIG_FLAG_EOS); |
841 | ||
16310a3c | 842 | return 0; |
c163b5ca LS |
843 | } |
844 | ||
c31b098f DDAG |
845 | static void block_save_pending(QEMUFile *f, void *opaque, uint64_t max_size, |
846 | uint64_t *non_postcopiable_pending, | |
847 | uint64_t *postcopiable_pending) | |
e4ed1541 | 848 | { |
6aaa9dae | 849 | /* Estimate pending number of bytes to send */ |
13197e3c PB |
850 | uint64_t pending; |
851 | ||
32c835ba | 852 | qemu_mutex_lock_iothread(); |
ef0716df PB |
853 | pending = get_remaining_dirty(); |
854 | qemu_mutex_unlock_iothread(); | |
855 | ||
52e850de | 856 | blk_mig_lock(); |
ef0716df PB |
857 | pending += block_mig_state.submitted * BLOCK_SIZE + |
858 | block_mig_state.read_done * BLOCK_SIZE; | |
859 | blk_mig_unlock(); | |
6aaa9dae SH |
860 | |
861 | /* Report at least one block pending during bulk phase */ | |
04636dc4 VSO |
862 | if (pending <= max_size && !block_mig_state.bulk_completed) { |
863 | pending = max_size + BLOCK_SIZE; | |
6aaa9dae | 864 | } |
e4ed1541 | 865 | |
6aaa9dae | 866 | DPRINTF("Enter save live pending %" PRIu64 "\n", pending); |
c31b098f DDAG |
867 | /* We don't do postcopy */ |
868 | *non_postcopiable_pending += pending; | |
e4ed1541 JQ |
869 | } |
870 | ||
c163b5ca LS |
871 | static int block_load(QEMUFile *f, void *opaque, int version_id) |
872 | { | |
01e61e2d | 873 | static int banner_printed; |
c163b5ca LS |
874 | int len, flags; |
875 | char device_name[256]; | |
876 | int64_t addr; | |
ad2964b4 | 877 | BlockBackend *blk, *blk_prev = NULL;; |
9bd9c7f5 | 878 | Error *local_err = NULL; |
c163b5ca | 879 | uint8_t *buf; |
77358b59 PR |
880 | int64_t total_sectors = 0; |
881 | int nr_sectors; | |
42802d47 | 882 | int ret; |
a55eb92c | 883 | |
c163b5ca | 884 | do { |
c163b5ca | 885 | addr = qemu_get_be64(f); |
a55eb92c | 886 | |
6ea44308 JK |
887 | flags = addr & ~BDRV_SECTOR_MASK; |
888 | addr >>= BDRV_SECTOR_BITS; | |
a55eb92c JK |
889 | |
890 | if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) { | |
c163b5ca LS |
891 | /* get device name */ |
892 | len = qemu_get_byte(f); | |
c163b5ca LS |
893 | qemu_get_buffer(f, (uint8_t *)device_name, len); |
894 | device_name[len] = '\0'; | |
a55eb92c | 895 | |
c9ebaf74 FZ |
896 | blk = blk_by_name(device_name); |
897 | if (!blk) { | |
4b640365 JK |
898 | fprintf(stderr, "Error unknown block device %s\n", |
899 | device_name); | |
900 | return -EINVAL; | |
901 | } | |
a55eb92c | 902 | |
ad2964b4 KW |
903 | if (blk != blk_prev) { |
904 | blk_prev = blk; | |
905 | total_sectors = blk_nb_sectors(blk); | |
77358b59 | 906 | if (total_sectors <= 0) { |
6daf194d | 907 | error_report("Error getting length of block device %s", |
77358b59 PR |
908 | device_name); |
909 | return -EINVAL; | |
910 | } | |
9bd9c7f5 | 911 | |
ad2964b4 | 912 | blk_invalidate_cache(blk, &local_err); |
9bd9c7f5 KW |
913 | if (local_err) { |
914 | error_report_err(local_err); | |
915 | return -EINVAL; | |
916 | } | |
77358b59 PR |
917 | } |
918 | ||
919 | if (total_sectors - addr < BDRV_SECTORS_PER_DIRTY_CHUNK) { | |
920 | nr_sectors = total_sectors - addr; | |
921 | } else { | |
922 | nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK; | |
923 | } | |
924 | ||
323004a3 | 925 | if (flags & BLK_MIG_FLAG_ZERO_BLOCK) { |
ad2964b4 KW |
926 | ret = blk_pwrite_zeroes(blk, addr * BDRV_SECTOR_SIZE, |
927 | nr_sectors * BDRV_SECTOR_SIZE, | |
928 | BDRV_REQ_MAY_UNMAP); | |
323004a3 PL |
929 | } else { |
930 | buf = g_malloc(BLOCK_SIZE); | |
931 | qemu_get_buffer(f, buf, BLOCK_SIZE); | |
ad2964b4 KW |
932 | ret = blk_pwrite(blk, addr * BDRV_SECTOR_SIZE, buf, |
933 | nr_sectors * BDRV_SECTOR_SIZE, 0); | |
323004a3 PL |
934 | g_free(buf); |
935 | } | |
575a58d7 | 936 | |
b02bea3a YT |
937 | if (ret < 0) { |
938 | return ret; | |
939 | } | |
01e61e2d JK |
940 | } else if (flags & BLK_MIG_FLAG_PROGRESS) { |
941 | if (!banner_printed) { | |
942 | printf("Receiving block device images\n"); | |
943 | banner_printed = 1; | |
944 | } | |
945 | printf("Completed %d %%%c", (int)addr, | |
946 | (addr == 100) ? '\n' : '\r'); | |
947 | fflush(stdout); | |
a55eb92c | 948 | } else if (!(flags & BLK_MIG_FLAG_EOS)) { |
d5f1f286 | 949 | fprintf(stderr, "Unknown block migration flags: %#x\n", flags); |
4b640365 JK |
950 | return -EINVAL; |
951 | } | |
42802d47 JQ |
952 | ret = qemu_file_get_error(f); |
953 | if (ret != 0) { | |
954 | return ret; | |
c163b5ca | 955 | } |
a55eb92c JK |
956 | } while (!(flags & BLK_MIG_FLAG_EOS)); |
957 | ||
c163b5ca LS |
958 | return 0; |
959 | } | |
960 | ||
6607ae23 | 961 | static void block_set_params(const MigrationParams *params, void *opaque) |
c163b5ca | 962 | { |
6607ae23 IY |
963 | block_mig_state.blk_enable = params->blk; |
964 | block_mig_state.shared_base = params->shared; | |
a55eb92c | 965 | |
c163b5ca | 966 | /* shared base means that blk_enable = 1 */ |
6607ae23 | 967 | block_mig_state.blk_enable |= params->shared; |
c163b5ca LS |
968 | } |
969 | ||
6bd68781 JQ |
970 | static bool block_is_active(void *opaque) |
971 | { | |
972 | return block_mig_state.blk_enable == 1; | |
973 | } | |
974 | ||
7a46d042 | 975 | static SaveVMHandlers savevm_block_handlers = { |
7908c78d | 976 | .set_params = block_set_params, |
d1315aac | 977 | .save_live_setup = block_save_setup, |
16310a3c | 978 | .save_live_iterate = block_save_iterate, |
a3e06c3d | 979 | .save_live_complete_precopy = block_save_complete, |
e4ed1541 | 980 | .save_live_pending = block_save_pending, |
7908c78d | 981 | .load_state = block_load, |
6ad2a215 | 982 | .cleanup = block_migration_cleanup, |
6bd68781 | 983 | .is_active = block_is_active, |
7908c78d JQ |
984 | }; |
985 | ||
c163b5ca | 986 | void blk_mig_init(void) |
a55eb92c | 987 | { |
5e5328be JK |
988 | QSIMPLEQ_INIT(&block_mig_state.bmds_list); |
989 | QSIMPLEQ_INIT(&block_mig_state.blk_list); | |
52e850de | 990 | qemu_mutex_init(&block_mig_state.lock); |
5e5328be | 991 | |
7908c78d JQ |
992 | register_savevm_live(NULL, "block", 0, 1, &savevm_block_handlers, |
993 | &block_mig_state); | |
c163b5ca | 994 | } |