1329c9b10SDr. David Alan Gilbert /*
2329c9b10SDr. David Alan Gilbert * QEMU live block migration
3329c9b10SDr. David Alan Gilbert *
4329c9b10SDr. David Alan Gilbert * Copyright IBM, Corp. 2009
5329c9b10SDr. David Alan Gilbert *
6329c9b10SDr. David Alan Gilbert * Authors:
7329c9b10SDr. David Alan Gilbert * Liran Schour <lirans@il.ibm.com>
8329c9b10SDr. David Alan Gilbert *
9329c9b10SDr. David Alan Gilbert * This work is licensed under the terms of the GNU GPL, version 2. See
10329c9b10SDr. David Alan Gilbert * the COPYING file in the top-level directory.
11329c9b10SDr. David Alan Gilbert *
12329c9b10SDr. David Alan Gilbert * Contributions after 2012-01-13 are licensed under the terms of the
13329c9b10SDr. David Alan Gilbert * GNU GPL, version 2 or (at your option) any later version.
14329c9b10SDr. David Alan Gilbert */
15329c9b10SDr. David Alan Gilbert
161393a485SPeter Maydell #include "qemu/osdep.h"
17da34e65cSMarkus Armbruster #include "qapi/error.h"
18329c9b10SDr. David Alan Gilbert #include "qemu/error-report.h"
19db725815SMarkus Armbruster #include "qemu/main-loop.h"
20f348b6d1SVeronia Bahaa #include "qemu/cutils.h"
21329c9b10SDr. David Alan Gilbert #include "qemu/queue.h"
222c9e6fecSJuan Quintela #include "block.h"
23e2c1c34fSMarkus Armbruster #include "block/dirty-bitmap.h"
242c9e6fecSJuan Quintela #include "migration/misc.h"
256666c96aSJuan Quintela #include "migration.h"
26e1fde0e0SJuan Quintela #include "migration-stats.h"
27f2a8f0a6SJuan Quintela #include "migration/register.h"
2808a0aee1SJuan Quintela #include "qemu-file.h"
29987772d9SJuan Quintela #include "migration/vmstate.h"
30c9ebaf74SFam Zheng #include "sysemu/block-backend.h"
31fe80c024SBihong Yu #include "trace.h"
321f0776f1SJuan Quintela #include "options.h"
33329c9b10SDr. David Alan Gilbert
344bcb7de0SPeter Maydell #define BLK_MIG_BLOCK_SIZE (1ULL << 20)
35a152bd00SStefan Hajnoczi #define BDRV_SECTORS_PER_DIRTY_CHUNK (BLK_MIG_BLOCK_SIZE >> BDRV_SECTOR_BITS)
36329c9b10SDr. David Alan Gilbert
37329c9b10SDr. David Alan Gilbert #define BLK_MIG_FLAG_DEVICE_BLOCK 0x01
38329c9b10SDr. David Alan Gilbert #define BLK_MIG_FLAG_EOS 0x02
39329c9b10SDr. David Alan Gilbert #define BLK_MIG_FLAG_PROGRESS 0x04
40329c9b10SDr. David Alan Gilbert #define BLK_MIG_FLAG_ZERO_BLOCK 0x08
41329c9b10SDr. David Alan Gilbert
42d6a644bbSEric Blake #define MAX_IS_ALLOCATED_SEARCH (65536 * BDRV_SECTOR_SIZE)
43329c9b10SDr. David Alan Gilbert
44ef9c5160SPeter Lieven #define MAX_IO_BUFFERS 512
4544815334SPeter Lieven #define MAX_PARALLEL_IO 16
46f77dcdbcSWen Congyang
47329c9b10SDr. David Alan Gilbert typedef struct BlkMigDevState {
48329c9b10SDr. David Alan Gilbert /* Written during setup phase. Can be read without a lock. */
49ebd2f9e7SKevin Wolf BlockBackend *blk;
50ebd2f9e7SKevin Wolf char *blk_name;
51329c9b10SDr. David Alan Gilbert int shared_base;
52329c9b10SDr. David Alan Gilbert int64_t total_sectors;
53329c9b10SDr. David Alan Gilbert QSIMPLEQ_ENTRY(BlkMigDevState) entry;
54ef0716dfSPaolo Bonzini Error *blocker;
55329c9b10SDr. David Alan Gilbert
56329c9b10SDr. David Alan Gilbert /* Only used by migration thread. Does not need a lock. */
57329c9b10SDr. David Alan Gilbert int bulk_completed;
58329c9b10SDr. David Alan Gilbert int64_t cur_sector;
59329c9b10SDr. David Alan Gilbert int64_t cur_dirty;
60329c9b10SDr. David Alan Gilbert
61ef0716dfSPaolo Bonzini /* Data in the aio_bitmap is protected by block migration lock.
62ef0716dfSPaolo Bonzini * Allocation and free happen during setup and cleanup respectively.
63ef0716dfSPaolo Bonzini */
64329c9b10SDr. David Alan Gilbert unsigned long *aio_bitmap;
65ef0716dfSPaolo Bonzini
66ef0716dfSPaolo Bonzini /* Protected by block migration lock. */
67329c9b10SDr. David Alan Gilbert int64_t completed_sectors;
68ef0716dfSPaolo Bonzini
69b49f4755SStefan Hajnoczi /* During migration this is protected by bdrv_dirty_bitmap_lock().
70ef0716dfSPaolo Bonzini * Allocation and free happen during setup and cleanup respectively.
71ef0716dfSPaolo Bonzini */
72329c9b10SDr. David Alan Gilbert BdrvDirtyBitmap *dirty_bitmap;
73329c9b10SDr. David Alan Gilbert } BlkMigDevState;
74329c9b10SDr. David Alan Gilbert
75329c9b10SDr. David Alan Gilbert typedef struct BlkMigBlock {
76329c9b10SDr. David Alan Gilbert /* Only used by migration thread. */
77329c9b10SDr. David Alan Gilbert uint8_t *buf;
78329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
79329c9b10SDr. David Alan Gilbert int64_t sector;
80329c9b10SDr. David Alan Gilbert int nr_sectors;
81329c9b10SDr. David Alan Gilbert QEMUIOVector qiov;
82329c9b10SDr. David Alan Gilbert BlockAIOCB *aiocb;
83329c9b10SDr. David Alan Gilbert
84329c9b10SDr. David Alan Gilbert /* Protected by block migration lock. */
85329c9b10SDr. David Alan Gilbert int ret;
86329c9b10SDr. David Alan Gilbert QSIMPLEQ_ENTRY(BlkMigBlock) entry;
87329c9b10SDr. David Alan Gilbert } BlkMigBlock;
88329c9b10SDr. David Alan Gilbert
89329c9b10SDr. David Alan Gilbert typedef struct BlkMigState {
90b58deb34SPaolo Bonzini QSIMPLEQ_HEAD(, BlkMigDevState) bmds_list;
91329c9b10SDr. David Alan Gilbert int64_t total_sector_sum;
92329c9b10SDr. David Alan Gilbert bool zero_blocks;
93329c9b10SDr. David Alan Gilbert
94329c9b10SDr. David Alan Gilbert /* Protected by lock. */
95b58deb34SPaolo Bonzini QSIMPLEQ_HEAD(, BlkMigBlock) blk_list;
96329c9b10SDr. David Alan Gilbert int submitted;
97329c9b10SDr. David Alan Gilbert int read_done;
98329c9b10SDr. David Alan Gilbert
99329c9b10SDr. David Alan Gilbert /* Only used by migration thread. Does not need a lock. */
100329c9b10SDr. David Alan Gilbert int transferred;
101329c9b10SDr. David Alan Gilbert int prev_progress;
102329c9b10SDr. David Alan Gilbert int bulk_completed;
103329c9b10SDr. David Alan Gilbert
104a4a411fbSStefan Hajnoczi /* Lock must be taken _inside_ the BQL. */
105329c9b10SDr. David Alan Gilbert QemuMutex lock;
106329c9b10SDr. David Alan Gilbert } BlkMigState;
107329c9b10SDr. David Alan Gilbert
108329c9b10SDr. David Alan Gilbert static BlkMigState block_mig_state;
109329c9b10SDr. David Alan Gilbert
blk_mig_lock(void)110329c9b10SDr. David Alan Gilbert static void blk_mig_lock(void)
111329c9b10SDr. David Alan Gilbert {
112329c9b10SDr. David Alan Gilbert qemu_mutex_lock(&block_mig_state.lock);
113329c9b10SDr. David Alan Gilbert }
114329c9b10SDr. David Alan Gilbert
blk_mig_unlock(void)115329c9b10SDr. David Alan Gilbert static void blk_mig_unlock(void)
116329c9b10SDr. David Alan Gilbert {
117329c9b10SDr. David Alan Gilbert qemu_mutex_unlock(&block_mig_state.lock);
118329c9b10SDr. David Alan Gilbert }
119329c9b10SDr. David Alan Gilbert
120a4a411fbSStefan Hajnoczi /* Must run outside of the BQL during the bulk phase,
121329c9b10SDr. David Alan Gilbert * or the VM will stall.
122329c9b10SDr. David Alan Gilbert */
123329c9b10SDr. David Alan Gilbert
blk_send(QEMUFile * f,BlkMigBlock * blk)124329c9b10SDr. David Alan Gilbert static void blk_send(QEMUFile *f, BlkMigBlock * blk)
125329c9b10SDr. David Alan Gilbert {
126329c9b10SDr. David Alan Gilbert int len;
127329c9b10SDr. David Alan Gilbert uint64_t flags = BLK_MIG_FLAG_DEVICE_BLOCK;
128329c9b10SDr. David Alan Gilbert
129329c9b10SDr. David Alan Gilbert if (block_mig_state.zero_blocks &&
130a152bd00SStefan Hajnoczi buffer_is_zero(blk->buf, BLK_MIG_BLOCK_SIZE)) {
131329c9b10SDr. David Alan Gilbert flags |= BLK_MIG_FLAG_ZERO_BLOCK;
132329c9b10SDr. David Alan Gilbert }
133329c9b10SDr. David Alan Gilbert
134329c9b10SDr. David Alan Gilbert /* sector number and flags */
135329c9b10SDr. David Alan Gilbert qemu_put_be64(f, (blk->sector << BDRV_SECTOR_BITS)
136329c9b10SDr. David Alan Gilbert | flags);
137329c9b10SDr. David Alan Gilbert
138329c9b10SDr. David Alan Gilbert /* device name */
139ebd2f9e7SKevin Wolf len = strlen(blk->bmds->blk_name);
140329c9b10SDr. David Alan Gilbert qemu_put_byte(f, len);
141ebd2f9e7SKevin Wolf qemu_put_buffer(f, (uint8_t *) blk->bmds->blk_name, len);
142329c9b10SDr. David Alan Gilbert
143329c9b10SDr. David Alan Gilbert /* if a block is zero we need to flush here since the network
144329c9b10SDr. David Alan Gilbert * bandwidth is now a lot higher than the storage device bandwidth.
145329c9b10SDr. David Alan Gilbert * thus if we queue zero blocks we slow down the migration */
146329c9b10SDr. David Alan Gilbert if (flags & BLK_MIG_FLAG_ZERO_BLOCK) {
147329c9b10SDr. David Alan Gilbert qemu_fflush(f);
148329c9b10SDr. David Alan Gilbert return;
149329c9b10SDr. David Alan Gilbert }
150329c9b10SDr. David Alan Gilbert
151a152bd00SStefan Hajnoczi qemu_put_buffer(f, blk->buf, BLK_MIG_BLOCK_SIZE);
152329c9b10SDr. David Alan Gilbert }
153329c9b10SDr. David Alan Gilbert
blk_mig_active(void)154329c9b10SDr. David Alan Gilbert int blk_mig_active(void)
155329c9b10SDr. David Alan Gilbert {
156329c9b10SDr. David Alan Gilbert return !QSIMPLEQ_EMPTY(&block_mig_state.bmds_list);
157329c9b10SDr. David Alan Gilbert }
158329c9b10SDr. David Alan Gilbert
blk_mig_bulk_active(void)1599ac78b61SPeter Lieven int blk_mig_bulk_active(void)
1609ac78b61SPeter Lieven {
1619ac78b61SPeter Lieven return blk_mig_active() && !block_mig_state.bulk_completed;
1629ac78b61SPeter Lieven }
1639ac78b61SPeter Lieven
blk_mig_bytes_transferred(void)164329c9b10SDr. David Alan Gilbert uint64_t blk_mig_bytes_transferred(void)
165329c9b10SDr. David Alan Gilbert {
166329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
167329c9b10SDr. David Alan Gilbert uint64_t sum = 0;
168329c9b10SDr. David Alan Gilbert
169329c9b10SDr. David Alan Gilbert blk_mig_lock();
170329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
171329c9b10SDr. David Alan Gilbert sum += bmds->completed_sectors;
172329c9b10SDr. David Alan Gilbert }
173329c9b10SDr. David Alan Gilbert blk_mig_unlock();
174329c9b10SDr. David Alan Gilbert return sum << BDRV_SECTOR_BITS;
175329c9b10SDr. David Alan Gilbert }
176329c9b10SDr. David Alan Gilbert
blk_mig_bytes_remaining(void)177329c9b10SDr. David Alan Gilbert uint64_t blk_mig_bytes_remaining(void)
178329c9b10SDr. David Alan Gilbert {
179329c9b10SDr. David Alan Gilbert return blk_mig_bytes_total() - blk_mig_bytes_transferred();
180329c9b10SDr. David Alan Gilbert }
181329c9b10SDr. David Alan Gilbert
blk_mig_bytes_total(void)182329c9b10SDr. David Alan Gilbert uint64_t blk_mig_bytes_total(void)
183329c9b10SDr. David Alan Gilbert {
184329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
185329c9b10SDr. David Alan Gilbert uint64_t sum = 0;
186329c9b10SDr. David Alan Gilbert
187329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
188329c9b10SDr. David Alan Gilbert sum += bmds->total_sectors;
189329c9b10SDr. David Alan Gilbert }
190329c9b10SDr. David Alan Gilbert return sum << BDRV_SECTOR_BITS;
191329c9b10SDr. David Alan Gilbert }
192329c9b10SDr. David Alan Gilbert
193329c9b10SDr. David Alan Gilbert
194329c9b10SDr. David Alan Gilbert /* Called with migration lock held. */
195329c9b10SDr. David Alan Gilbert
bmds_aio_inflight(BlkMigDevState * bmds,int64_t sector)196329c9b10SDr. David Alan Gilbert static int bmds_aio_inflight(BlkMigDevState *bmds, int64_t sector)
197329c9b10SDr. David Alan Gilbert {
198329c9b10SDr. David Alan Gilbert int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK;
199329c9b10SDr. David Alan Gilbert
2002c5451caSPaolo Bonzini if (sector < bmds->total_sectors) {
201329c9b10SDr. David Alan Gilbert return !!(bmds->aio_bitmap[chunk / (sizeof(unsigned long) * 8)] &
202329c9b10SDr. David Alan Gilbert (1UL << (chunk % (sizeof(unsigned long) * 8))));
203329c9b10SDr. David Alan Gilbert } else {
204329c9b10SDr. David Alan Gilbert return 0;
205329c9b10SDr. David Alan Gilbert }
206329c9b10SDr. David Alan Gilbert }
207329c9b10SDr. David Alan Gilbert
208329c9b10SDr. David Alan Gilbert /* Called with migration lock held. */
209329c9b10SDr. David Alan Gilbert
bmds_set_aio_inflight(BlkMigDevState * bmds,int64_t sector_num,int nb_sectors,int set)210329c9b10SDr. David Alan Gilbert static void bmds_set_aio_inflight(BlkMigDevState *bmds, int64_t sector_num,
211329c9b10SDr. David Alan Gilbert int nb_sectors, int set)
212329c9b10SDr. David Alan Gilbert {
213329c9b10SDr. David Alan Gilbert int64_t start, end;
214329c9b10SDr. David Alan Gilbert unsigned long val, idx, bit;
215329c9b10SDr. David Alan Gilbert
216329c9b10SDr. David Alan Gilbert start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK;
217329c9b10SDr. David Alan Gilbert end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK;
218329c9b10SDr. David Alan Gilbert
219329c9b10SDr. David Alan Gilbert for (; start <= end; start++) {
220329c9b10SDr. David Alan Gilbert idx = start / (sizeof(unsigned long) * 8);
221329c9b10SDr. David Alan Gilbert bit = start % (sizeof(unsigned long) * 8);
222329c9b10SDr. David Alan Gilbert val = bmds->aio_bitmap[idx];
223329c9b10SDr. David Alan Gilbert if (set) {
224329c9b10SDr. David Alan Gilbert val |= 1UL << bit;
225329c9b10SDr. David Alan Gilbert } else {
226329c9b10SDr. David Alan Gilbert val &= ~(1UL << bit);
227329c9b10SDr. David Alan Gilbert }
228329c9b10SDr. David Alan Gilbert bmds->aio_bitmap[idx] = val;
229329c9b10SDr. David Alan Gilbert }
230329c9b10SDr. David Alan Gilbert }
231329c9b10SDr. David Alan Gilbert
alloc_aio_bitmap(BlkMigDevState * bmds)232329c9b10SDr. David Alan Gilbert static void alloc_aio_bitmap(BlkMigDevState *bmds)
233329c9b10SDr. David Alan Gilbert {
234329c9b10SDr. David Alan Gilbert int64_t bitmap_size;
235329c9b10SDr. David Alan Gilbert
2362c5451caSPaolo Bonzini bitmap_size = bmds->total_sectors + BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
237329c9b10SDr. David Alan Gilbert bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
238329c9b10SDr. David Alan Gilbert
239329c9b10SDr. David Alan Gilbert bmds->aio_bitmap = g_malloc0(bitmap_size);
240329c9b10SDr. David Alan Gilbert }
241329c9b10SDr. David Alan Gilbert
242329c9b10SDr. David Alan Gilbert /* Never hold migration lock when yielding to the main loop! */
243329c9b10SDr. David Alan Gilbert
blk_mig_read_cb(void * opaque,int ret)244329c9b10SDr. David Alan Gilbert static void blk_mig_read_cb(void *opaque, int ret)
245329c9b10SDr. David Alan Gilbert {
246329c9b10SDr. David Alan Gilbert BlkMigBlock *blk = opaque;
247329c9b10SDr. David Alan Gilbert
248329c9b10SDr. David Alan Gilbert blk_mig_lock();
249329c9b10SDr. David Alan Gilbert blk->ret = ret;
250329c9b10SDr. David Alan Gilbert
251329c9b10SDr. David Alan Gilbert QSIMPLEQ_INSERT_TAIL(&block_mig_state.blk_list, blk, entry);
252329c9b10SDr. David Alan Gilbert bmds_set_aio_inflight(blk->bmds, blk->sector, blk->nr_sectors, 0);
253329c9b10SDr. David Alan Gilbert
254329c9b10SDr. David Alan Gilbert block_mig_state.submitted--;
255329c9b10SDr. David Alan Gilbert block_mig_state.read_done++;
256329c9b10SDr. David Alan Gilbert assert(block_mig_state.submitted >= 0);
257329c9b10SDr. David Alan Gilbert blk_mig_unlock();
258329c9b10SDr. David Alan Gilbert }
259329c9b10SDr. David Alan Gilbert
260329c9b10SDr. David Alan Gilbert /* Called with no lock taken. */
261329c9b10SDr. David Alan Gilbert
mig_save_device_bulk(QEMUFile * f,BlkMigDevState * bmds)262329c9b10SDr. David Alan Gilbert static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
263329c9b10SDr. David Alan Gilbert {
264329c9b10SDr. David Alan Gilbert int64_t total_sectors = bmds->total_sectors;
265329c9b10SDr. David Alan Gilbert int64_t cur_sector = bmds->cur_sector;
266ebd2f9e7SKevin Wolf BlockBackend *bb = bmds->blk;
267329c9b10SDr. David Alan Gilbert BlkMigBlock *blk;
268329c9b10SDr. David Alan Gilbert int nr_sectors;
269d6a644bbSEric Blake int64_t count;
270329c9b10SDr. David Alan Gilbert
271329c9b10SDr. David Alan Gilbert if (bmds->shared_base) {
272195801d7SStefan Hajnoczi bql_lock();
273d6a644bbSEric Blake /* Skip unallocated sectors; intentionally treats failure or
274d6a644bbSEric Blake * partial sector as an allocated sector */
275329c9b10SDr. David Alan Gilbert while (cur_sector < total_sectors &&
276d6a644bbSEric Blake !bdrv_is_allocated(blk_bs(bb), cur_sector * BDRV_SECTOR_SIZE,
277d6a644bbSEric Blake MAX_IS_ALLOCATED_SEARCH, &count)) {
278d6a644bbSEric Blake if (count < BDRV_SECTOR_SIZE) {
279d6a644bbSEric Blake break;
280d6a644bbSEric Blake }
281d6a644bbSEric Blake cur_sector += count >> BDRV_SECTOR_BITS;
282329c9b10SDr. David Alan Gilbert }
283195801d7SStefan Hajnoczi bql_unlock();
284329c9b10SDr. David Alan Gilbert }
285329c9b10SDr. David Alan Gilbert
286329c9b10SDr. David Alan Gilbert if (cur_sector >= total_sectors) {
287329c9b10SDr. David Alan Gilbert bmds->cur_sector = bmds->completed_sectors = total_sectors;
288329c9b10SDr. David Alan Gilbert return 1;
289329c9b10SDr. David Alan Gilbert }
290329c9b10SDr. David Alan Gilbert
291329c9b10SDr. David Alan Gilbert bmds->completed_sectors = cur_sector;
292329c9b10SDr. David Alan Gilbert
293329c9b10SDr. David Alan Gilbert cur_sector &= ~((int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK - 1);
294329c9b10SDr. David Alan Gilbert
295329c9b10SDr. David Alan Gilbert /* we are going to transfer a full block even if it is not allocated */
296329c9b10SDr. David Alan Gilbert nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
297329c9b10SDr. David Alan Gilbert
298329c9b10SDr. David Alan Gilbert if (total_sectors - cur_sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
299329c9b10SDr. David Alan Gilbert nr_sectors = total_sectors - cur_sector;
300329c9b10SDr. David Alan Gilbert }
301329c9b10SDr. David Alan Gilbert
302329c9b10SDr. David Alan Gilbert blk = g_new(BlkMigBlock, 1);
303a152bd00SStefan Hajnoczi blk->buf = g_malloc(BLK_MIG_BLOCK_SIZE);
304329c9b10SDr. David Alan Gilbert blk->bmds = bmds;
305329c9b10SDr. David Alan Gilbert blk->sector = cur_sector;
306329c9b10SDr. David Alan Gilbert blk->nr_sectors = nr_sectors;
307329c9b10SDr. David Alan Gilbert
308f556f37bSVladimir Sementsov-Ogievskiy qemu_iovec_init_buf(&blk->qiov, blk->buf, nr_sectors * BDRV_SECTOR_SIZE);
309329c9b10SDr. David Alan Gilbert
310329c9b10SDr. David Alan Gilbert blk_mig_lock();
311329c9b10SDr. David Alan Gilbert block_mig_state.submitted++;
312329c9b10SDr. David Alan Gilbert blk_mig_unlock();
313329c9b10SDr. David Alan Gilbert
314b49f4755SStefan Hajnoczi /*
315b49f4755SStefan Hajnoczi * The migration thread does not have an AioContext. Lock the BQL so that
316b49f4755SStefan Hajnoczi * I/O runs in the main loop AioContext (see
317b49f4755SStefan Hajnoczi * qemu_get_current_aio_context()).
318ef0716dfSPaolo Bonzini */
319195801d7SStefan Hajnoczi bql_lock();
320e0d7f73eSEric Blake bdrv_reset_dirty_bitmap(bmds->dirty_bitmap, cur_sector * BDRV_SECTOR_SIZE,
321e0d7f73eSEric Blake nr_sectors * BDRV_SECTOR_SIZE);
32286b124bcSPeter Lieven blk->aiocb = blk_aio_preadv(bb, cur_sector * BDRV_SECTOR_SIZE, &blk->qiov,
32386b124bcSPeter Lieven 0, blk_mig_read_cb, blk);
324195801d7SStefan Hajnoczi bql_unlock();
325329c9b10SDr. David Alan Gilbert
326329c9b10SDr. David Alan Gilbert bmds->cur_sector = cur_sector + nr_sectors;
327329c9b10SDr. David Alan Gilbert return (bmds->cur_sector >= total_sectors);
328329c9b10SDr. David Alan Gilbert }
329329c9b10SDr. David Alan Gilbert
330a4a411fbSStefan Hajnoczi /* Called with the BQL taken. */
331329c9b10SDr. David Alan Gilbert
set_dirty_tracking(void)332329c9b10SDr. David Alan Gilbert static int set_dirty_tracking(void)
333329c9b10SDr. David Alan Gilbert {
334329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
335329c9b10SDr. David Alan Gilbert int ret;
336329c9b10SDr. David Alan Gilbert
337329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
338ebd2f9e7SKevin Wolf bmds->dirty_bitmap = bdrv_create_dirty_bitmap(blk_bs(bmds->blk),
339a152bd00SStefan Hajnoczi BLK_MIG_BLOCK_SIZE,
340a152bd00SStefan Hajnoczi NULL, NULL);
341329c9b10SDr. David Alan Gilbert if (!bmds->dirty_bitmap) {
342329c9b10SDr. David Alan Gilbert ret = -errno;
343329c9b10SDr. David Alan Gilbert goto fail;
344329c9b10SDr. David Alan Gilbert }
345329c9b10SDr. David Alan Gilbert }
346329c9b10SDr. David Alan Gilbert return 0;
347329c9b10SDr. David Alan Gilbert
348329c9b10SDr. David Alan Gilbert fail:
349329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
350329c9b10SDr. David Alan Gilbert if (bmds->dirty_bitmap) {
3515deb6cbdSVladimir Sementsov-Ogievskiy bdrv_release_dirty_bitmap(bmds->dirty_bitmap);
352329c9b10SDr. David Alan Gilbert }
353329c9b10SDr. David Alan Gilbert }
354329c9b10SDr. David Alan Gilbert return ret;
355329c9b10SDr. David Alan Gilbert }
356329c9b10SDr. David Alan Gilbert
357a4a411fbSStefan Hajnoczi /* Called with the BQL taken. */
358ef0716dfSPaolo Bonzini
unset_dirty_tracking(void)359329c9b10SDr. David Alan Gilbert static void unset_dirty_tracking(void)
360329c9b10SDr. David Alan Gilbert {
361329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
362329c9b10SDr. David Alan Gilbert
363329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
364f187609fSFabiano Rosas if (bmds->dirty_bitmap) {
3655deb6cbdSVladimir Sementsov-Ogievskiy bdrv_release_dirty_bitmap(bmds->dirty_bitmap);
366329c9b10SDr. David Alan Gilbert }
367329c9b10SDr. David Alan Gilbert }
368f187609fSFabiano Rosas }
369329c9b10SDr. David Alan Gilbert
init_blk_migration(QEMUFile * f,Error ** errp)370150da48cSCédric Le Goater static int init_blk_migration(QEMUFile *f, Error **errp)
371329c9b10SDr. David Alan Gilbert {
372329c9b10SDr. David Alan Gilbert BlockDriverState *bs;
373329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
374329c9b10SDr. David Alan Gilbert int64_t sectors;
37588be7b4bSKevin Wolf BdrvNextIterator it;
376ebd2f9e7SKevin Wolf int i, num_bs = 0;
377ebd2f9e7SKevin Wolf struct {
378ebd2f9e7SKevin Wolf BlkMigDevState *bmds;
379ebd2f9e7SKevin Wolf BlockDriverState *bs;
380ebd2f9e7SKevin Wolf } *bmds_bs;
3816f5ef23aSKevin Wolf int ret;
382329c9b10SDr. David Alan Gilbert
3832b3912f1SKevin Wolf GRAPH_RDLOCK_GUARD_MAINLOOP();
3842b3912f1SKevin Wolf
385329c9b10SDr. David Alan Gilbert block_mig_state.submitted = 0;
386329c9b10SDr. David Alan Gilbert block_mig_state.read_done = 0;
387329c9b10SDr. David Alan Gilbert block_mig_state.transferred = 0;
388329c9b10SDr. David Alan Gilbert block_mig_state.total_sector_sum = 0;
389329c9b10SDr. David Alan Gilbert block_mig_state.prev_progress = -1;
390329c9b10SDr. David Alan Gilbert block_mig_state.bulk_completed = 0;
391329c9b10SDr. David Alan Gilbert block_mig_state.zero_blocks = migrate_zero_blocks();
392329c9b10SDr. David Alan Gilbert
39388be7b4bSKevin Wolf for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
394ebd2f9e7SKevin Wolf num_bs++;
395ebd2f9e7SKevin Wolf }
396ebd2f9e7SKevin Wolf bmds_bs = g_malloc0(num_bs * sizeof(*bmds_bs));
397ebd2f9e7SKevin Wolf
398ebd2f9e7SKevin Wolf for (i = 0, bs = bdrv_first(&it); bs; bs = bdrv_next(&it), i++) {
399329c9b10SDr. David Alan Gilbert if (bdrv_is_read_only(bs)) {
400329c9b10SDr. David Alan Gilbert continue;
401329c9b10SDr. David Alan Gilbert }
402329c9b10SDr. David Alan Gilbert
403329c9b10SDr. David Alan Gilbert sectors = bdrv_nb_sectors(bs);
4042e128776SCédric Le Goater if (sectors == 0) {
4052e128776SCédric Le Goater continue;
4062e128776SCédric Le Goater }
4072e128776SCédric Le Goater if (sectors < 0) {
408150da48cSCédric Le Goater error_setg(errp, "Error getting length of block device %s",
409150da48cSCédric Le Goater bdrv_get_device_name(bs));
4106f5ef23aSKevin Wolf ret = sectors;
4115e003f17SMax Reitz bdrv_next_cleanup(&it);
412ebd2f9e7SKevin Wolf goto out;
413329c9b10SDr. David Alan Gilbert }
414329c9b10SDr. David Alan Gilbert
415329c9b10SDr. David Alan Gilbert bmds = g_new0(BlkMigDevState, 1);
416d861ab3aSKevin Wolf bmds->blk = blk_new(qemu_get_aio_context(),
417d861ab3aSKevin Wolf BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
418ebd2f9e7SKevin Wolf bmds->blk_name = g_strdup(bdrv_get_device_name(bs));
419329c9b10SDr. David Alan Gilbert bmds->bulk_completed = 0;
420329c9b10SDr. David Alan Gilbert bmds->total_sectors = sectors;
421329c9b10SDr. David Alan Gilbert bmds->completed_sectors = 0;
4226f8be708SJuan Quintela bmds->shared_base = migrate_block_incremental();
423ebd2f9e7SKevin Wolf
424ebd2f9e7SKevin Wolf assert(i < num_bs);
425ebd2f9e7SKevin Wolf bmds_bs[i].bmds = bmds;
426ebd2f9e7SKevin Wolf bmds_bs[i].bs = bs;
427329c9b10SDr. David Alan Gilbert
428329c9b10SDr. David Alan Gilbert block_mig_state.total_sector_sum += sectors;
429329c9b10SDr. David Alan Gilbert
430329c9b10SDr. David Alan Gilbert if (bmds->shared_base) {
431fe80c024SBihong Yu trace_migration_block_init_shared(bdrv_get_device_name(bs));
432329c9b10SDr. David Alan Gilbert } else {
433fe80c024SBihong Yu trace_migration_block_init_full(bdrv_get_device_name(bs));
434329c9b10SDr. David Alan Gilbert }
435329c9b10SDr. David Alan Gilbert
436329c9b10SDr. David Alan Gilbert QSIMPLEQ_INSERT_TAIL(&block_mig_state.bmds_list, bmds, entry);
437329c9b10SDr. David Alan Gilbert }
438ebd2f9e7SKevin Wolf
439ebd2f9e7SKevin Wolf /* Can only insert new BDSes now because doing so while iterating block
440ebd2f9e7SKevin Wolf * devices may end up in a deadlock (iterating the new BDSes, too). */
441ebd2f9e7SKevin Wolf for (i = 0; i < num_bs; i++) {
4427f3de3f0SMarkus Armbruster bmds = bmds_bs[i].bmds;
4437f3de3f0SMarkus Armbruster bs = bmds_bs[i].bs;
444ebd2f9e7SKevin Wolf
445ebd2f9e7SKevin Wolf if (bmds) {
446150da48cSCédric Le Goater ret = blk_insert_bs(bmds->blk, bs, errp);
4476f5ef23aSKevin Wolf if (ret < 0) {
4486f5ef23aSKevin Wolf goto out;
4496f5ef23aSKevin Wolf }
450ebd2f9e7SKevin Wolf
451ebd2f9e7SKevin Wolf alloc_aio_bitmap(bmds);
452ebd2f9e7SKevin Wolf error_setg(&bmds->blocker, "block device is in use by migration");
453ebd2f9e7SKevin Wolf bdrv_op_block_all(bs, bmds->blocker);
454ebd2f9e7SKevin Wolf }
455ebd2f9e7SKevin Wolf }
456ebd2f9e7SKevin Wolf
4576f5ef23aSKevin Wolf ret = 0;
458ebd2f9e7SKevin Wolf out:
459ebd2f9e7SKevin Wolf g_free(bmds_bs);
4606f5ef23aSKevin Wolf return ret;
461329c9b10SDr. David Alan Gilbert }
462329c9b10SDr. David Alan Gilbert
463329c9b10SDr. David Alan Gilbert /* Called with no lock taken. */
464329c9b10SDr. David Alan Gilbert
blk_mig_save_bulked_block(QEMUFile * f)465329c9b10SDr. David Alan Gilbert static int blk_mig_save_bulked_block(QEMUFile *f)
466329c9b10SDr. David Alan Gilbert {
467329c9b10SDr. David Alan Gilbert int64_t completed_sector_sum = 0;
468329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
469329c9b10SDr. David Alan Gilbert int progress;
470329c9b10SDr. David Alan Gilbert int ret = 0;
471329c9b10SDr. David Alan Gilbert
472329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
473329c9b10SDr. David Alan Gilbert if (bmds->bulk_completed == 0) {
474329c9b10SDr. David Alan Gilbert if (mig_save_device_bulk(f, bmds) == 1) {
475329c9b10SDr. David Alan Gilbert /* completed bulk section for this device */
476329c9b10SDr. David Alan Gilbert bmds->bulk_completed = 1;
477329c9b10SDr. David Alan Gilbert }
478329c9b10SDr. David Alan Gilbert completed_sector_sum += bmds->completed_sectors;
479329c9b10SDr. David Alan Gilbert ret = 1;
480329c9b10SDr. David Alan Gilbert break;
481329c9b10SDr. David Alan Gilbert } else {
482329c9b10SDr. David Alan Gilbert completed_sector_sum += bmds->completed_sectors;
483329c9b10SDr. David Alan Gilbert }
484329c9b10SDr. David Alan Gilbert }
485329c9b10SDr. David Alan Gilbert
486329c9b10SDr. David Alan Gilbert if (block_mig_state.total_sector_sum != 0) {
487329c9b10SDr. David Alan Gilbert progress = completed_sector_sum * 100 /
488329c9b10SDr. David Alan Gilbert block_mig_state.total_sector_sum;
489329c9b10SDr. David Alan Gilbert } else {
490329c9b10SDr. David Alan Gilbert progress = 100;
491329c9b10SDr. David Alan Gilbert }
492329c9b10SDr. David Alan Gilbert if (progress != block_mig_state.prev_progress) {
493329c9b10SDr. David Alan Gilbert block_mig_state.prev_progress = progress;
494329c9b10SDr. David Alan Gilbert qemu_put_be64(f, (progress << BDRV_SECTOR_BITS)
495329c9b10SDr. David Alan Gilbert | BLK_MIG_FLAG_PROGRESS);
496163b8663SPhilippe Mathieu-Daudé trace_migration_block_progression(progress);
497329c9b10SDr. David Alan Gilbert }
498329c9b10SDr. David Alan Gilbert
499329c9b10SDr. David Alan Gilbert return ret;
500329c9b10SDr. David Alan Gilbert }
501329c9b10SDr. David Alan Gilbert
blk_mig_reset_dirty_cursor(void)502329c9b10SDr. David Alan Gilbert static void blk_mig_reset_dirty_cursor(void)
503329c9b10SDr. David Alan Gilbert {
504329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
505329c9b10SDr. David Alan Gilbert
506329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
507329c9b10SDr. David Alan Gilbert bmds->cur_dirty = 0;
508329c9b10SDr. David Alan Gilbert }
509329c9b10SDr. David Alan Gilbert }
510329c9b10SDr. David Alan Gilbert
511a4a411fbSStefan Hajnoczi /* Called with the BQL taken. */
512329c9b10SDr. David Alan Gilbert
mig_save_device_dirty(QEMUFile * f,BlkMigDevState * bmds,int is_async)513329c9b10SDr. David Alan Gilbert static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds,
514329c9b10SDr. David Alan Gilbert int is_async)
515329c9b10SDr. David Alan Gilbert {
516329c9b10SDr. David Alan Gilbert BlkMigBlock *blk;
517329c9b10SDr. David Alan Gilbert int64_t total_sectors = bmds->total_sectors;
518329c9b10SDr. David Alan Gilbert int64_t sector;
519329c9b10SDr. David Alan Gilbert int nr_sectors;
520329c9b10SDr. David Alan Gilbert int ret = -EIO;
521329c9b10SDr. David Alan Gilbert
522329c9b10SDr. David Alan Gilbert for (sector = bmds->cur_dirty; sector < bmds->total_sectors;) {
523329c9b10SDr. David Alan Gilbert blk_mig_lock();
524329c9b10SDr. David Alan Gilbert if (bmds_aio_inflight(bmds, sector)) {
525329c9b10SDr. David Alan Gilbert blk_mig_unlock();
526ebd2f9e7SKevin Wolf blk_drain(bmds->blk);
527329c9b10SDr. David Alan Gilbert } else {
528329c9b10SDr. David Alan Gilbert blk_mig_unlock();
529329c9b10SDr. David Alan Gilbert }
530b64bd51eSPaolo Bonzini bdrv_dirty_bitmap_lock(bmds->dirty_bitmap);
53128636b82SJohn Snow if (bdrv_dirty_bitmap_get_locked(bmds->dirty_bitmap,
5323b5d4df0SEric Blake sector * BDRV_SECTOR_SIZE)) {
533329c9b10SDr. David Alan Gilbert if (total_sectors - sector < BDRV_SECTORS_PER_DIRTY_CHUNK) {
534329c9b10SDr. David Alan Gilbert nr_sectors = total_sectors - sector;
535329c9b10SDr. David Alan Gilbert } else {
536329c9b10SDr. David Alan Gilbert nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
537329c9b10SDr. David Alan Gilbert }
538e0d7f73eSEric Blake bdrv_reset_dirty_bitmap_locked(bmds->dirty_bitmap,
539e0d7f73eSEric Blake sector * BDRV_SECTOR_SIZE,
540e0d7f73eSEric Blake nr_sectors * BDRV_SECTOR_SIZE);
541b64bd51eSPaolo Bonzini bdrv_dirty_bitmap_unlock(bmds->dirty_bitmap);
542c0bad499SPaolo Bonzini
543329c9b10SDr. David Alan Gilbert blk = g_new(BlkMigBlock, 1);
544a152bd00SStefan Hajnoczi blk->buf = g_malloc(BLK_MIG_BLOCK_SIZE);
545329c9b10SDr. David Alan Gilbert blk->bmds = bmds;
546329c9b10SDr. David Alan Gilbert blk->sector = sector;
547329c9b10SDr. David Alan Gilbert blk->nr_sectors = nr_sectors;
548329c9b10SDr. David Alan Gilbert
549329c9b10SDr. David Alan Gilbert if (is_async) {
550f556f37bSVladimir Sementsov-Ogievskiy qemu_iovec_init_buf(&blk->qiov, blk->buf,
551f556f37bSVladimir Sementsov-Ogievskiy nr_sectors * BDRV_SECTOR_SIZE);
552329c9b10SDr. David Alan Gilbert
553ebd2f9e7SKevin Wolf blk->aiocb = blk_aio_preadv(bmds->blk,
554ebd2f9e7SKevin Wolf sector * BDRV_SECTOR_SIZE,
555ebd2f9e7SKevin Wolf &blk->qiov, 0, blk_mig_read_cb,
556ebd2f9e7SKevin Wolf blk);
557329c9b10SDr. David Alan Gilbert
558329c9b10SDr. David Alan Gilbert blk_mig_lock();
559329c9b10SDr. David Alan Gilbert block_mig_state.submitted++;
560329c9b10SDr. David Alan Gilbert bmds_set_aio_inflight(bmds, sector, nr_sectors, 1);
561329c9b10SDr. David Alan Gilbert blk_mig_unlock();
562329c9b10SDr. David Alan Gilbert } else {
5633b35d454SAlberto Faria ret = blk_pread(bmds->blk, sector * BDRV_SECTOR_SIZE,
564a9262f55SAlberto Faria nr_sectors * BDRV_SECTOR_SIZE, blk->buf, 0);
565329c9b10SDr. David Alan Gilbert if (ret < 0) {
566329c9b10SDr. David Alan Gilbert goto error;
567329c9b10SDr. David Alan Gilbert }
568329c9b10SDr. David Alan Gilbert blk_send(f, blk);
569329c9b10SDr. David Alan Gilbert
570329c9b10SDr. David Alan Gilbert g_free(blk->buf);
571329c9b10SDr. David Alan Gilbert g_free(blk);
572329c9b10SDr. David Alan Gilbert }
573329c9b10SDr. David Alan Gilbert
5741cf6aa74SLidong Chen sector += nr_sectors;
5751cf6aa74SLidong Chen bmds->cur_dirty = sector;
576329c9b10SDr. David Alan Gilbert break;
577329c9b10SDr. David Alan Gilbert }
578b64bd51eSPaolo Bonzini
579b64bd51eSPaolo Bonzini bdrv_dirty_bitmap_unlock(bmds->dirty_bitmap);
580329c9b10SDr. David Alan Gilbert sector += BDRV_SECTORS_PER_DIRTY_CHUNK;
581329c9b10SDr. David Alan Gilbert bmds->cur_dirty = sector;
582329c9b10SDr. David Alan Gilbert }
583329c9b10SDr. David Alan Gilbert
584329c9b10SDr. David Alan Gilbert return (bmds->cur_dirty >= bmds->total_sectors);
585329c9b10SDr. David Alan Gilbert
586329c9b10SDr. David Alan Gilbert error:
587fe80c024SBihong Yu trace_migration_block_save_device_dirty(sector);
588329c9b10SDr. David Alan Gilbert g_free(blk->buf);
589329c9b10SDr. David Alan Gilbert g_free(blk);
590329c9b10SDr. David Alan Gilbert return ret;
591329c9b10SDr. David Alan Gilbert }
592329c9b10SDr. David Alan Gilbert
593a4a411fbSStefan Hajnoczi /* Called with the BQL taken.
594329c9b10SDr. David Alan Gilbert *
595329c9b10SDr. David Alan Gilbert * return value:
596329c9b10SDr. David Alan Gilbert * 0: too much data for max_downtime
597329c9b10SDr. David Alan Gilbert * 1: few enough data for max_downtime
598329c9b10SDr. David Alan Gilbert */
blk_mig_save_dirty_block(QEMUFile * f,int is_async)599329c9b10SDr. David Alan Gilbert static int blk_mig_save_dirty_block(QEMUFile *f, int is_async)
600329c9b10SDr. David Alan Gilbert {
601329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
602329c9b10SDr. David Alan Gilbert int ret = 1;
603329c9b10SDr. David Alan Gilbert
604329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
605329c9b10SDr. David Alan Gilbert ret = mig_save_device_dirty(f, bmds, is_async);
606329c9b10SDr. David Alan Gilbert if (ret <= 0) {
607329c9b10SDr. David Alan Gilbert break;
608329c9b10SDr. David Alan Gilbert }
609329c9b10SDr. David Alan Gilbert }
610329c9b10SDr. David Alan Gilbert
611329c9b10SDr. David Alan Gilbert return ret;
612329c9b10SDr. David Alan Gilbert }
613329c9b10SDr. David Alan Gilbert
614329c9b10SDr. David Alan Gilbert /* Called with no locks taken. */
615329c9b10SDr. David Alan Gilbert
flush_blks(QEMUFile * f)616329c9b10SDr. David Alan Gilbert static int flush_blks(QEMUFile *f)
617329c9b10SDr. David Alan Gilbert {
618329c9b10SDr. David Alan Gilbert BlkMigBlock *blk;
619329c9b10SDr. David Alan Gilbert int ret = 0;
620329c9b10SDr. David Alan Gilbert
621fe80c024SBihong Yu trace_migration_block_flush_blks("Enter", block_mig_state.submitted,
622fe80c024SBihong Yu block_mig_state.read_done,
623329c9b10SDr. David Alan Gilbert block_mig_state.transferred);
624329c9b10SDr. David Alan Gilbert
625329c9b10SDr. David Alan Gilbert blk_mig_lock();
626329c9b10SDr. David Alan Gilbert while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
627e1fde0e0SJuan Quintela if (migration_rate_exceeded(f)) {
628329c9b10SDr. David Alan Gilbert break;
629329c9b10SDr. David Alan Gilbert }
630329c9b10SDr. David Alan Gilbert if (blk->ret < 0) {
631329c9b10SDr. David Alan Gilbert ret = blk->ret;
632329c9b10SDr. David Alan Gilbert break;
633329c9b10SDr. David Alan Gilbert }
634329c9b10SDr. David Alan Gilbert
635329c9b10SDr. David Alan Gilbert QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
636329c9b10SDr. David Alan Gilbert blk_mig_unlock();
637329c9b10SDr. David Alan Gilbert blk_send(f, blk);
638329c9b10SDr. David Alan Gilbert blk_mig_lock();
639329c9b10SDr. David Alan Gilbert
640329c9b10SDr. David Alan Gilbert g_free(blk->buf);
641329c9b10SDr. David Alan Gilbert g_free(blk);
642329c9b10SDr. David Alan Gilbert
643329c9b10SDr. David Alan Gilbert block_mig_state.read_done--;
644329c9b10SDr. David Alan Gilbert block_mig_state.transferred++;
645329c9b10SDr. David Alan Gilbert assert(block_mig_state.read_done >= 0);
646329c9b10SDr. David Alan Gilbert }
647329c9b10SDr. David Alan Gilbert blk_mig_unlock();
648329c9b10SDr. David Alan Gilbert
649fe80c024SBihong Yu trace_migration_block_flush_blks("Exit", block_mig_state.submitted,
650fe80c024SBihong Yu block_mig_state.read_done,
651329c9b10SDr. David Alan Gilbert block_mig_state.transferred);
652329c9b10SDr. David Alan Gilbert return ret;
653329c9b10SDr. David Alan Gilbert }
654329c9b10SDr. David Alan Gilbert
655a4a411fbSStefan Hajnoczi /* Called with the BQL taken. */
656329c9b10SDr. David Alan Gilbert
get_remaining_dirty(void)657329c9b10SDr. David Alan Gilbert static int64_t get_remaining_dirty(void)
658329c9b10SDr. David Alan Gilbert {
659329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
660329c9b10SDr. David Alan Gilbert int64_t dirty = 0;
661329c9b10SDr. David Alan Gilbert
662329c9b10SDr. David Alan Gilbert QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
663b49f4755SStefan Hajnoczi bdrv_dirty_bitmap_lock(bmds->dirty_bitmap);
66420dca810SJohn Snow dirty += bdrv_get_dirty_count(bmds->dirty_bitmap);
665b49f4755SStefan Hajnoczi bdrv_dirty_bitmap_unlock(bmds->dirty_bitmap);
666329c9b10SDr. David Alan Gilbert }
667329c9b10SDr. David Alan Gilbert
6689a46dba7SEric Blake return dirty;
669329c9b10SDr. David Alan Gilbert }
670329c9b10SDr. David Alan Gilbert
671329c9b10SDr. David Alan Gilbert
672362fdf17SKevin Wolf
673a4a411fbSStefan Hajnoczi /* Called with the BQL taken. */
block_migration_cleanup_bmds(void)674362fdf17SKevin Wolf static void block_migration_cleanup_bmds(void)
675329c9b10SDr. David Alan Gilbert {
676329c9b10SDr. David Alan Gilbert BlkMigDevState *bmds;
677f187609fSFabiano Rosas BlockDriverState *bs;
678329c9b10SDr. David Alan Gilbert
679329c9b10SDr. David Alan Gilbert unset_dirty_tracking();
680329c9b10SDr. David Alan Gilbert
681329c9b10SDr. David Alan Gilbert while ((bmds = QSIMPLEQ_FIRST(&block_mig_state.bmds_list)) != NULL) {
682329c9b10SDr. David Alan Gilbert QSIMPLEQ_REMOVE_HEAD(&block_mig_state.bmds_list, entry);
683f187609fSFabiano Rosas
684f187609fSFabiano Rosas bs = blk_bs(bmds->blk);
685f187609fSFabiano Rosas if (bs) {
686f187609fSFabiano Rosas bdrv_op_unblock_all(bs, bmds->blocker);
687f187609fSFabiano Rosas }
688329c9b10SDr. David Alan Gilbert error_free(bmds->blocker);
689ebd2f9e7SKevin Wolf blk_unref(bmds->blk);
690ebd2f9e7SKevin Wolf g_free(bmds->blk_name);
691329c9b10SDr. David Alan Gilbert g_free(bmds->aio_bitmap);
692329c9b10SDr. David Alan Gilbert g_free(bmds);
693329c9b10SDr. David Alan Gilbert }
694362fdf17SKevin Wolf }
695362fdf17SKevin Wolf
696a4a411fbSStefan Hajnoczi /* Called with the BQL taken. */
block_migration_cleanup(void * opaque)697362fdf17SKevin Wolf static void block_migration_cleanup(void *opaque)
698362fdf17SKevin Wolf {
699362fdf17SKevin Wolf BlkMigBlock *blk;
700362fdf17SKevin Wolf
701362fdf17SKevin Wolf bdrv_drain_all();
702362fdf17SKevin Wolf
703362fdf17SKevin Wolf block_migration_cleanup_bmds();
704329c9b10SDr. David Alan Gilbert
705ef0716dfSPaolo Bonzini blk_mig_lock();
706329c9b10SDr. David Alan Gilbert while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
707329c9b10SDr. David Alan Gilbert QSIMPLEQ_REMOVE_HEAD(&block_mig_state.blk_list, entry);
708329c9b10SDr. David Alan Gilbert g_free(blk->buf);
709329c9b10SDr. David Alan Gilbert g_free(blk);
710329c9b10SDr. David Alan Gilbert }
711329c9b10SDr. David Alan Gilbert blk_mig_unlock();
712329c9b10SDr. David Alan Gilbert }
713329c9b10SDr. David Alan Gilbert
block_save_setup(QEMUFile * f,void * opaque,Error ** errp)71401c3ac68SCédric Le Goater static int block_save_setup(QEMUFile *f, void *opaque, Error **errp)
715329c9b10SDr. David Alan Gilbert {
716329c9b10SDr. David Alan Gilbert int ret;
717329c9b10SDr. David Alan Gilbert
718fe80c024SBihong Yu trace_migration_block_save("setup", block_mig_state.submitted,
719fe80c024SBihong Yu block_mig_state.transferred);
720329c9b10SDr. David Alan Gilbert
72166db46caSJuan Quintela warn_report("block migration is deprecated;"
72266db46caSJuan Quintela " use blockdev-mirror with NBD instead");
72366db46caSJuan Quintela
72401c3ac68SCédric Le Goater ret = init_blk_migration(f, errp);
7256f5ef23aSKevin Wolf if (ret < 0) {
7266f5ef23aSKevin Wolf return ret;
7276f5ef23aSKevin Wolf }
728329c9b10SDr. David Alan Gilbert
729329c9b10SDr. David Alan Gilbert /* start track dirty blocks */
730329c9b10SDr. David Alan Gilbert ret = set_dirty_tracking();
731ef0716dfSPaolo Bonzini if (ret) {
73201c3ac68SCédric Le Goater error_setg_errno(errp, -ret, "Failed to start block dirty tracking");
733329c9b10SDr. David Alan Gilbert return ret;
734329c9b10SDr. David Alan Gilbert }
735329c9b10SDr. David Alan Gilbert
736329c9b10SDr. David Alan Gilbert ret = flush_blks(f);
737150da48cSCédric Le Goater if (ret) {
73801c3ac68SCédric Le Goater error_setg_errno(errp, -ret, "Flushing block failed");
739150da48cSCédric Le Goater return ret;
740150da48cSCédric Le Goater }
741329c9b10SDr. David Alan Gilbert blk_mig_reset_dirty_cursor();
742329c9b10SDr. David Alan Gilbert qemu_put_be64(f, BLK_MIG_FLAG_EOS);
743329c9b10SDr. David Alan Gilbert
744329c9b10SDr. David Alan Gilbert return ret;
745329c9b10SDr. David Alan Gilbert }
746329c9b10SDr. David Alan Gilbert
block_save_iterate(QEMUFile * f,void * opaque)747329c9b10SDr. David Alan Gilbert static int block_save_iterate(QEMUFile *f, void *opaque)
748329c9b10SDr. David Alan Gilbert {
749329c9b10SDr. David Alan Gilbert int ret;
750e9c0eed7SJuan Quintela uint64_t last_bytes = qemu_file_transferred(f);
751329c9b10SDr. David Alan Gilbert
752fe80c024SBihong Yu trace_migration_block_save("iterate", block_mig_state.submitted,
753fe80c024SBihong Yu block_mig_state.transferred);
754329c9b10SDr. David Alan Gilbert
755329c9b10SDr. David Alan Gilbert ret = flush_blks(f);
756329c9b10SDr. David Alan Gilbert if (ret) {
757329c9b10SDr. David Alan Gilbert return ret;
758329c9b10SDr. David Alan Gilbert }
759329c9b10SDr. David Alan Gilbert
760329c9b10SDr. David Alan Gilbert blk_mig_reset_dirty_cursor();
761329c9b10SDr. David Alan Gilbert
762329c9b10SDr. David Alan Gilbert /* control the rate of transfer */
763329c9b10SDr. David Alan Gilbert blk_mig_lock();
764a152bd00SStefan Hajnoczi while (block_mig_state.read_done * BLK_MIG_BLOCK_SIZE <
765e1fde0e0SJuan Quintela migration_rate_get() &&
76644815334SPeter Lieven block_mig_state.submitted < MAX_PARALLEL_IO &&
767ef9c5160SPeter Lieven (block_mig_state.submitted + block_mig_state.read_done) <
768ef9c5160SPeter Lieven MAX_IO_BUFFERS) {
769329c9b10SDr. David Alan Gilbert blk_mig_unlock();
770329c9b10SDr. David Alan Gilbert if (block_mig_state.bulk_completed == 0) {
771329c9b10SDr. David Alan Gilbert /* first finish the bulk phase */
772329c9b10SDr. David Alan Gilbert if (blk_mig_save_bulked_block(f) == 0) {
773329c9b10SDr. David Alan Gilbert /* finished saving bulk on all devices */
774329c9b10SDr. David Alan Gilbert block_mig_state.bulk_completed = 1;
775329c9b10SDr. David Alan Gilbert }
776329c9b10SDr. David Alan Gilbert ret = 0;
777329c9b10SDr. David Alan Gilbert } else {
778a4a411fbSStefan Hajnoczi /* Always called with the BQL taken for
779329c9b10SDr. David Alan Gilbert * simplicity, block_save_complete also calls it.
780329c9b10SDr. David Alan Gilbert */
781195801d7SStefan Hajnoczi bql_lock();
782329c9b10SDr. David Alan Gilbert ret = blk_mig_save_dirty_block(f, 1);
783195801d7SStefan Hajnoczi bql_unlock();
784329c9b10SDr. David Alan Gilbert }
785329c9b10SDr. David Alan Gilbert if (ret < 0) {
786329c9b10SDr. David Alan Gilbert return ret;
787329c9b10SDr. David Alan Gilbert }
788329c9b10SDr. David Alan Gilbert blk_mig_lock();
789329c9b10SDr. David Alan Gilbert if (ret != 0) {
790329c9b10SDr. David Alan Gilbert /* no more dirty blocks */
791329c9b10SDr. David Alan Gilbert break;
792329c9b10SDr. David Alan Gilbert }
793329c9b10SDr. David Alan Gilbert }
794329c9b10SDr. David Alan Gilbert blk_mig_unlock();
795329c9b10SDr. David Alan Gilbert
796329c9b10SDr. David Alan Gilbert ret = flush_blks(f);
797329c9b10SDr. David Alan Gilbert if (ret) {
798329c9b10SDr. David Alan Gilbert return ret;
799329c9b10SDr. David Alan Gilbert }
800329c9b10SDr. David Alan Gilbert
801329c9b10SDr. David Alan Gilbert qemu_put_be64(f, BLK_MIG_FLAG_EOS);
802e9c0eed7SJuan Quintela uint64_t delta_bytes = qemu_file_transferred(f) - last_bytes;
803f3030d34SJuan Quintela return (delta_bytes > 0);
804329c9b10SDr. David Alan Gilbert }
805329c9b10SDr. David Alan Gilbert
806a4a411fbSStefan Hajnoczi /* Called with the BQL taken. */
807329c9b10SDr. David Alan Gilbert
block_save_complete(QEMUFile * f,void * opaque)808329c9b10SDr. David Alan Gilbert static int block_save_complete(QEMUFile *f, void *opaque)
809329c9b10SDr. David Alan Gilbert {
810329c9b10SDr. David Alan Gilbert int ret;
811329c9b10SDr. David Alan Gilbert
812fe80c024SBihong Yu trace_migration_block_save("complete", block_mig_state.submitted,
813fe80c024SBihong Yu block_mig_state.transferred);
814329c9b10SDr. David Alan Gilbert
815329c9b10SDr. David Alan Gilbert ret = flush_blks(f);
816329c9b10SDr. David Alan Gilbert if (ret) {
817329c9b10SDr. David Alan Gilbert return ret;
818329c9b10SDr. David Alan Gilbert }
819329c9b10SDr. David Alan Gilbert
820329c9b10SDr. David Alan Gilbert blk_mig_reset_dirty_cursor();
821329c9b10SDr. David Alan Gilbert
822329c9b10SDr. David Alan Gilbert /* we know for sure that save bulk is completed and
823329c9b10SDr. David Alan Gilbert all async read completed */
824329c9b10SDr. David Alan Gilbert blk_mig_lock();
825329c9b10SDr. David Alan Gilbert assert(block_mig_state.submitted == 0);
826329c9b10SDr. David Alan Gilbert blk_mig_unlock();
827329c9b10SDr. David Alan Gilbert
828329c9b10SDr. David Alan Gilbert do {
829329c9b10SDr. David Alan Gilbert ret = blk_mig_save_dirty_block(f, 0);
830329c9b10SDr. David Alan Gilbert if (ret < 0) {
831329c9b10SDr. David Alan Gilbert return ret;
832329c9b10SDr. David Alan Gilbert }
833329c9b10SDr. David Alan Gilbert } while (ret == 0);
834329c9b10SDr. David Alan Gilbert
835329c9b10SDr. David Alan Gilbert /* report completion */
836329c9b10SDr. David Alan Gilbert qemu_put_be64(f, (100 << BDRV_SECTOR_BITS) | BLK_MIG_FLAG_PROGRESS);
837329c9b10SDr. David Alan Gilbert
838fe80c024SBihong Yu trace_migration_block_save_complete();
839329c9b10SDr. David Alan Gilbert
840329c9b10SDr. David Alan Gilbert qemu_put_be64(f, BLK_MIG_FLAG_EOS);
841329c9b10SDr. David Alan Gilbert
842362fdf17SKevin Wolf /* Make sure that our BlockBackends are gone, so that the block driver
843362fdf17SKevin Wolf * nodes can be inactivated. */
844362fdf17SKevin Wolf block_migration_cleanup_bmds();
845362fdf17SKevin Wolf
846329c9b10SDr. David Alan Gilbert return 0;
847329c9b10SDr. David Alan Gilbert }
848329c9b10SDr. David Alan Gilbert
block_state_pending(void * opaque,uint64_t * must_precopy,uint64_t * can_postcopy)84924beea4eSJuan Quintela static void block_state_pending(void *opaque, uint64_t *must_precopy,
85024beea4eSJuan Quintela uint64_t *can_postcopy)
851329c9b10SDr. David Alan Gilbert {
852329c9b10SDr. David Alan Gilbert /* Estimate pending number of bytes to send */
853329c9b10SDr. David Alan Gilbert uint64_t pending;
854329c9b10SDr. David Alan Gilbert
855195801d7SStefan Hajnoczi bql_lock();
856ef0716dfSPaolo Bonzini pending = get_remaining_dirty();
857195801d7SStefan Hajnoczi bql_unlock();
858ef0716dfSPaolo Bonzini
859329c9b10SDr. David Alan Gilbert blk_mig_lock();
860a152bd00SStefan Hajnoczi pending += block_mig_state.submitted * BLK_MIG_BLOCK_SIZE +
861a152bd00SStefan Hajnoczi block_mig_state.read_done * BLK_MIG_BLOCK_SIZE;
862ef0716dfSPaolo Bonzini blk_mig_unlock();
863329c9b10SDr. David Alan Gilbert
864329c9b10SDr. David Alan Gilbert /* Report at least one block pending during bulk phase */
865b5280437SJuan Quintela if (!pending && !block_mig_state.bulk_completed) {
866b5280437SJuan Quintela pending = BLK_MIG_BLOCK_SIZE;
867329c9b10SDr. David Alan Gilbert }
868329c9b10SDr. David Alan Gilbert
869c8df4a7aSJuan Quintela trace_migration_block_state_pending(pending);
870c31b098fSDr. David Alan Gilbert /* We don't do postcopy */
87124beea4eSJuan Quintela *must_precopy += pending;
872329c9b10SDr. David Alan Gilbert }
873329c9b10SDr. David Alan Gilbert
block_load(QEMUFile * f,void * opaque,int version_id)874329c9b10SDr. David Alan Gilbert static int block_load(QEMUFile *f, void *opaque, int version_id)
875329c9b10SDr. David Alan Gilbert {
876329c9b10SDr. David Alan Gilbert static int banner_printed;
877329c9b10SDr. David Alan Gilbert int len, flags;
878329c9b10SDr. David Alan Gilbert char device_name[256];
879329c9b10SDr. David Alan Gilbert int64_t addr;
8803c254ab8SLadi Prosek BlockBackend *blk, *blk_prev = NULL;
8819bd9c7f5SKevin Wolf Error *local_err = NULL;
882329c9b10SDr. David Alan Gilbert uint8_t *buf;
883329c9b10SDr. David Alan Gilbert int64_t total_sectors = 0;
884329c9b10SDr. David Alan Gilbert int nr_sectors;
885329c9b10SDr. David Alan Gilbert int ret;
8863928d50bSLidong Chen BlockDriverInfo bdi;
887a152bd00SStefan Hajnoczi int cluster_size = BLK_MIG_BLOCK_SIZE;
888329c9b10SDr. David Alan Gilbert
889329c9b10SDr. David Alan Gilbert do {
890329c9b10SDr. David Alan Gilbert addr = qemu_get_be64(f);
891329c9b10SDr. David Alan Gilbert
89289725715SNir Soffer flags = addr & (BDRV_SECTOR_SIZE - 1);
893329c9b10SDr. David Alan Gilbert addr >>= BDRV_SECTOR_BITS;
894329c9b10SDr. David Alan Gilbert
895329c9b10SDr. David Alan Gilbert if (flags & BLK_MIG_FLAG_DEVICE_BLOCK) {
896329c9b10SDr. David Alan Gilbert /* get device name */
897329c9b10SDr. David Alan Gilbert len = qemu_get_byte(f);
898329c9b10SDr. David Alan Gilbert qemu_get_buffer(f, (uint8_t *)device_name, len);
899329c9b10SDr. David Alan Gilbert device_name[len] = '\0';
900329c9b10SDr. David Alan Gilbert
901c9ebaf74SFam Zheng blk = blk_by_name(device_name);
902c9ebaf74SFam Zheng if (!blk) {
903329c9b10SDr. David Alan Gilbert fprintf(stderr, "Error unknown block device %s\n",
904329c9b10SDr. David Alan Gilbert device_name);
905329c9b10SDr. David Alan Gilbert return -EINVAL;
906329c9b10SDr. David Alan Gilbert }
907329c9b10SDr. David Alan Gilbert
908ad2964b4SKevin Wolf if (blk != blk_prev) {
909ad2964b4SKevin Wolf blk_prev = blk;
910ad2964b4SKevin Wolf total_sectors = blk_nb_sectors(blk);
911329c9b10SDr. David Alan Gilbert if (total_sectors <= 0) {
912329c9b10SDr. David Alan Gilbert error_report("Error getting length of block device %s",
913329c9b10SDr. David Alan Gilbert device_name);
914329c9b10SDr. David Alan Gilbert return -EINVAL;
915329c9b10SDr. David Alan Gilbert }
9169bd9c7f5SKevin Wolf
9173b717194SEmanuele Giuseppe Esposito blk_activate(blk, &local_err);
9189bd9c7f5SKevin Wolf if (local_err) {
9199bd9c7f5SKevin Wolf error_report_err(local_err);
9209bd9c7f5SKevin Wolf return -EINVAL;
9219bd9c7f5SKevin Wolf }
9223928d50bSLidong Chen
9233928d50bSLidong Chen ret = bdrv_get_info(blk_bs(blk), &bdi);
9243928d50bSLidong Chen if (ret == 0 && bdi.cluster_size > 0 &&
925a152bd00SStefan Hajnoczi bdi.cluster_size <= BLK_MIG_BLOCK_SIZE &&
926a152bd00SStefan Hajnoczi BLK_MIG_BLOCK_SIZE % bdi.cluster_size == 0) {
9273928d50bSLidong Chen cluster_size = bdi.cluster_size;
9283928d50bSLidong Chen } else {
929a152bd00SStefan Hajnoczi cluster_size = BLK_MIG_BLOCK_SIZE;
9303928d50bSLidong Chen }
931329c9b10SDr. David Alan Gilbert }
932329c9b10SDr. David Alan Gilbert
933329c9b10SDr. David Alan Gilbert if (total_sectors - addr < BDRV_SECTORS_PER_DIRTY_CHUNK) {
934329c9b10SDr. David Alan Gilbert nr_sectors = total_sectors - addr;
935329c9b10SDr. David Alan Gilbert } else {
936329c9b10SDr. David Alan Gilbert nr_sectors = BDRV_SECTORS_PER_DIRTY_CHUNK;
937329c9b10SDr. David Alan Gilbert }
938329c9b10SDr. David Alan Gilbert
939329c9b10SDr. David Alan Gilbert if (flags & BLK_MIG_FLAG_ZERO_BLOCK) {
940ad2964b4SKevin Wolf ret = blk_pwrite_zeroes(blk, addr * BDRV_SECTOR_SIZE,
941ad2964b4SKevin Wolf nr_sectors * BDRV_SECTOR_SIZE,
942329c9b10SDr. David Alan Gilbert BDRV_REQ_MAY_UNMAP);
943329c9b10SDr. David Alan Gilbert } else {
9443928d50bSLidong Chen int i;
9453928d50bSLidong Chen int64_t cur_addr;
9463928d50bSLidong Chen uint8_t *cur_buf;
9473928d50bSLidong Chen
948a152bd00SStefan Hajnoczi buf = g_malloc(BLK_MIG_BLOCK_SIZE);
949a152bd00SStefan Hajnoczi qemu_get_buffer(f, buf, BLK_MIG_BLOCK_SIZE);
950a152bd00SStefan Hajnoczi for (i = 0; i < BLK_MIG_BLOCK_SIZE / cluster_size; i++) {
9513928d50bSLidong Chen cur_addr = addr * BDRV_SECTOR_SIZE + i * cluster_size;
9523928d50bSLidong Chen cur_buf = buf + i * cluster_size;
9533928d50bSLidong Chen
9543928d50bSLidong Chen if ((!block_mig_state.zero_blocks ||
955a152bd00SStefan Hajnoczi cluster_size < BLK_MIG_BLOCK_SIZE) &&
9563928d50bSLidong Chen buffer_is_zero(cur_buf, cluster_size)) {
9573928d50bSLidong Chen ret = blk_pwrite_zeroes(blk, cur_addr,
9583928d50bSLidong Chen cluster_size,
9593928d50bSLidong Chen BDRV_REQ_MAY_UNMAP);
9603928d50bSLidong Chen } else {
961a9262f55SAlberto Faria ret = blk_pwrite(blk, cur_addr, cluster_size, cur_buf,
962a9262f55SAlberto Faria 0);
9633928d50bSLidong Chen }
9643928d50bSLidong Chen if (ret < 0) {
9653928d50bSLidong Chen break;
9663928d50bSLidong Chen }
9673928d50bSLidong Chen }
968329c9b10SDr. David Alan Gilbert g_free(buf);
969329c9b10SDr. David Alan Gilbert }
970329c9b10SDr. David Alan Gilbert
971329c9b10SDr. David Alan Gilbert if (ret < 0) {
972329c9b10SDr. David Alan Gilbert return ret;
973329c9b10SDr. David Alan Gilbert }
974329c9b10SDr. David Alan Gilbert } else if (flags & BLK_MIG_FLAG_PROGRESS) {
975329c9b10SDr. David Alan Gilbert if (!banner_printed) {
976329c9b10SDr. David Alan Gilbert printf("Receiving block device images\n");
977329c9b10SDr. David Alan Gilbert banner_printed = 1;
978329c9b10SDr. David Alan Gilbert }
979329c9b10SDr. David Alan Gilbert printf("Completed %d %%%c", (int)addr,
980329c9b10SDr. David Alan Gilbert (addr == 100) ? '\n' : '\r');
981329c9b10SDr. David Alan Gilbert fflush(stdout);
982329c9b10SDr. David Alan Gilbert } else if (!(flags & BLK_MIG_FLAG_EOS)) {
98329fccadeSBihong Yu fprintf(stderr, "Unknown block migration flags: 0x%x\n", flags);
984329c9b10SDr. David Alan Gilbert return -EINVAL;
985329c9b10SDr. David Alan Gilbert }
986329c9b10SDr. David Alan Gilbert ret = qemu_file_get_error(f);
987329c9b10SDr. David Alan Gilbert if (ret != 0) {
988329c9b10SDr. David Alan Gilbert return ret;
989329c9b10SDr. David Alan Gilbert }
990329c9b10SDr. David Alan Gilbert } while (!(flags & BLK_MIG_FLAG_EOS));
991329c9b10SDr. David Alan Gilbert
992329c9b10SDr. David Alan Gilbert return 0;
993329c9b10SDr. David Alan Gilbert }
994329c9b10SDr. David Alan Gilbert
block_is_active(void * opaque)995329c9b10SDr. David Alan Gilbert static bool block_is_active(void *opaque)
996329c9b10SDr. David Alan Gilbert {
9979d4b1e5fSJuan Quintela return migrate_block();
998329c9b10SDr. David Alan Gilbert }
999329c9b10SDr. David Alan Gilbert
1000329c9b10SDr. David Alan Gilbert static SaveVMHandlers savevm_block_handlers = {
10019907e842SJuan Quintela .save_setup = block_save_setup,
1002329c9b10SDr. David Alan Gilbert .save_live_iterate = block_save_iterate,
1003a3e06c3dSDr. David Alan Gilbert .save_live_complete_precopy = block_save_complete,
1004c8df4a7aSJuan Quintela .state_pending_exact = block_state_pending,
1005c8df4a7aSJuan Quintela .state_pending_estimate = block_state_pending,
1006329c9b10SDr. David Alan Gilbert .load_state = block_load,
100770f794fcSJuan Quintela .save_cleanup = block_migration_cleanup,
1008329c9b10SDr. David Alan Gilbert .is_active = block_is_active,
1009329c9b10SDr. David Alan Gilbert };
1010329c9b10SDr. David Alan Gilbert
blk_mig_init(void)1011329c9b10SDr. David Alan Gilbert void blk_mig_init(void)
1012329c9b10SDr. David Alan Gilbert {
1013329c9b10SDr. David Alan Gilbert QSIMPLEQ_INIT(&block_mig_state.bmds_list);
1014329c9b10SDr. David Alan Gilbert QSIMPLEQ_INIT(&block_mig_state.blk_list);
1015329c9b10SDr. David Alan Gilbert qemu_mutex_init(&block_mig_state.lock);
1016329c9b10SDr. David Alan Gilbert
1017ce62df53SDr. David Alan Gilbert register_savevm_live("block", 0, 1, &savevm_block_handlers,
1018329c9b10SDr. David Alan Gilbert &block_mig_state);
1019329c9b10SDr. David Alan Gilbert }
1020