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