1893f7ebaSPaolo Bonzini /* 2893f7ebaSPaolo Bonzini * Image mirroring 3893f7ebaSPaolo Bonzini * 4893f7ebaSPaolo Bonzini * Copyright Red Hat, Inc. 2012 5893f7ebaSPaolo Bonzini * 6893f7ebaSPaolo Bonzini * Authors: 7893f7ebaSPaolo Bonzini * Paolo Bonzini <pbonzini@redhat.com> 8893f7ebaSPaolo Bonzini * 9893f7ebaSPaolo Bonzini * This work is licensed under the terms of the GNU LGPL, version 2 or later. 10893f7ebaSPaolo Bonzini * See the COPYING.LIB file in the top-level directory. 11893f7ebaSPaolo Bonzini * 12893f7ebaSPaolo Bonzini */ 13893f7ebaSPaolo Bonzini 14893f7ebaSPaolo Bonzini #include "trace.h" 15737e150eSPaolo Bonzini #include "block/blockjob.h" 16737e150eSPaolo Bonzini #include "block/block_int.h" 17*cc7a8ea7SMarkus Armbruster #include "qapi/qmp/qerror.h" 18893f7ebaSPaolo Bonzini #include "qemu/ratelimit.h" 19b812f671SPaolo Bonzini #include "qemu/bitmap.h" 20893f7ebaSPaolo Bonzini 21893f7ebaSPaolo Bonzini #define SLICE_TIME 100000000ULL /* ns */ 22402a4741SPaolo Bonzini #define MAX_IN_FLIGHT 16 23402a4741SPaolo Bonzini 24402a4741SPaolo Bonzini /* The mirroring buffer is a list of granularity-sized chunks. 25402a4741SPaolo Bonzini * Free chunks are organized in a list. 26402a4741SPaolo Bonzini */ 27402a4741SPaolo Bonzini typedef struct MirrorBuffer { 28402a4741SPaolo Bonzini QSIMPLEQ_ENTRY(MirrorBuffer) next; 29402a4741SPaolo Bonzini } MirrorBuffer; 30893f7ebaSPaolo Bonzini 31893f7ebaSPaolo Bonzini typedef struct MirrorBlockJob { 32893f7ebaSPaolo Bonzini BlockJob common; 33893f7ebaSPaolo Bonzini RateLimit limit; 34893f7ebaSPaolo Bonzini BlockDriverState *target; 355bc361b8SFam Zheng BlockDriverState *base; 3609158f00SBenoît Canet /* The name of the graph node to replace */ 3709158f00SBenoît Canet char *replaces; 3809158f00SBenoît Canet /* The BDS to replace */ 3909158f00SBenoît Canet BlockDriverState *to_replace; 4009158f00SBenoît Canet /* Used to block operations on the drive-mirror-replace target */ 4109158f00SBenoît Canet Error *replace_blocker; 4203544a6eSFam Zheng bool is_none_mode; 43b952b558SPaolo Bonzini BlockdevOnError on_source_error, on_target_error; 44d63ffd87SPaolo Bonzini bool synced; 45d63ffd87SPaolo Bonzini bool should_complete; 46893f7ebaSPaolo Bonzini int64_t sector_num; 47eee13dfeSPaolo Bonzini int64_t granularity; 48b812f671SPaolo Bonzini size_t buf_size; 49b21c7652SMax Reitz int64_t bdev_length; 50b812f671SPaolo Bonzini unsigned long *cow_bitmap; 51e4654d2dSFam Zheng BdrvDirtyBitmap *dirty_bitmap; 528f0720ecSPaolo Bonzini HBitmapIter hbi; 53893f7ebaSPaolo Bonzini uint8_t *buf; 54402a4741SPaolo Bonzini QSIMPLEQ_HEAD(, MirrorBuffer) buf_free; 55402a4741SPaolo Bonzini int buf_free_count; 56bd48bde8SPaolo Bonzini 57402a4741SPaolo Bonzini unsigned long *in_flight_bitmap; 58bd48bde8SPaolo Bonzini int in_flight; 59b21c7652SMax Reitz int sectors_in_flight; 60bd48bde8SPaolo Bonzini int ret; 61893f7ebaSPaolo Bonzini } MirrorBlockJob; 62893f7ebaSPaolo Bonzini 63bd48bde8SPaolo Bonzini typedef struct MirrorOp { 64bd48bde8SPaolo Bonzini MirrorBlockJob *s; 65bd48bde8SPaolo Bonzini QEMUIOVector qiov; 66bd48bde8SPaolo Bonzini int64_t sector_num; 67bd48bde8SPaolo Bonzini int nb_sectors; 68bd48bde8SPaolo Bonzini } MirrorOp; 69bd48bde8SPaolo Bonzini 70b952b558SPaolo Bonzini static BlockErrorAction mirror_error_action(MirrorBlockJob *s, bool read, 71b952b558SPaolo Bonzini int error) 72b952b558SPaolo Bonzini { 73b952b558SPaolo Bonzini s->synced = false; 74b952b558SPaolo Bonzini if (read) { 75b952b558SPaolo Bonzini return block_job_error_action(&s->common, s->common.bs, 76b952b558SPaolo Bonzini s->on_source_error, true, error); 77b952b558SPaolo Bonzini } else { 78b952b558SPaolo Bonzini return block_job_error_action(&s->common, s->target, 79b952b558SPaolo Bonzini s->on_target_error, false, error); 80b952b558SPaolo Bonzini } 81b952b558SPaolo Bonzini } 82b952b558SPaolo Bonzini 83bd48bde8SPaolo Bonzini static void mirror_iteration_done(MirrorOp *op, int ret) 84bd48bde8SPaolo Bonzini { 85bd48bde8SPaolo Bonzini MirrorBlockJob *s = op->s; 86402a4741SPaolo Bonzini struct iovec *iov; 87bd48bde8SPaolo Bonzini int64_t chunk_num; 88402a4741SPaolo Bonzini int i, nb_chunks, sectors_per_chunk; 89bd48bde8SPaolo Bonzini 90bd48bde8SPaolo Bonzini trace_mirror_iteration_done(s, op->sector_num, op->nb_sectors, ret); 91bd48bde8SPaolo Bonzini 92bd48bde8SPaolo Bonzini s->in_flight--; 93b21c7652SMax Reitz s->sectors_in_flight -= op->nb_sectors; 94402a4741SPaolo Bonzini iov = op->qiov.iov; 95402a4741SPaolo Bonzini for (i = 0; i < op->qiov.niov; i++) { 96402a4741SPaolo Bonzini MirrorBuffer *buf = (MirrorBuffer *) iov[i].iov_base; 97402a4741SPaolo Bonzini QSIMPLEQ_INSERT_TAIL(&s->buf_free, buf, next); 98402a4741SPaolo Bonzini s->buf_free_count++; 99402a4741SPaolo Bonzini } 100402a4741SPaolo Bonzini 101bd48bde8SPaolo Bonzini sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS; 102bd48bde8SPaolo Bonzini chunk_num = op->sector_num / sectors_per_chunk; 103bd48bde8SPaolo Bonzini nb_chunks = op->nb_sectors / sectors_per_chunk; 104402a4741SPaolo Bonzini bitmap_clear(s->in_flight_bitmap, chunk_num, nb_chunks); 105b21c7652SMax Reitz if (ret >= 0) { 106b21c7652SMax Reitz if (s->cow_bitmap) { 107bd48bde8SPaolo Bonzini bitmap_set(s->cow_bitmap, chunk_num, nb_chunks); 108bd48bde8SPaolo Bonzini } 109b21c7652SMax Reitz s->common.offset += (uint64_t)op->nb_sectors * BDRV_SECTOR_SIZE; 110b21c7652SMax Reitz } 111bd48bde8SPaolo Bonzini 1126df3bf8eSZhang Min qemu_iovec_destroy(&op->qiov); 113bd48bde8SPaolo Bonzini g_slice_free(MirrorOp, op); 1147b770c72SStefan Hajnoczi 1157b770c72SStefan Hajnoczi /* Enter coroutine when it is not sleeping. The coroutine sleeps to 1167b770c72SStefan Hajnoczi * rate-limit itself. The coroutine will eventually resume since there is 1177b770c72SStefan Hajnoczi * a sleep timeout so don't wake it early. 1187b770c72SStefan Hajnoczi */ 1197b770c72SStefan Hajnoczi if (s->common.busy) { 120bd48bde8SPaolo Bonzini qemu_coroutine_enter(s->common.co, NULL); 121bd48bde8SPaolo Bonzini } 1227b770c72SStefan Hajnoczi } 123bd48bde8SPaolo Bonzini 124bd48bde8SPaolo Bonzini static void mirror_write_complete(void *opaque, int ret) 125bd48bde8SPaolo Bonzini { 126bd48bde8SPaolo Bonzini MirrorOp *op = opaque; 127bd48bde8SPaolo Bonzini MirrorBlockJob *s = op->s; 128bd48bde8SPaolo Bonzini if (ret < 0) { 129bd48bde8SPaolo Bonzini BlockErrorAction action; 130bd48bde8SPaolo Bonzini 13120dca810SJohn Snow bdrv_set_dirty_bitmap(s->dirty_bitmap, op->sector_num, op->nb_sectors); 132bd48bde8SPaolo Bonzini action = mirror_error_action(s, false, -ret); 133a589569fSWenchao Xia if (action == BLOCK_ERROR_ACTION_REPORT && s->ret >= 0) { 134bd48bde8SPaolo Bonzini s->ret = ret; 135bd48bde8SPaolo Bonzini } 136bd48bde8SPaolo Bonzini } 137bd48bde8SPaolo Bonzini mirror_iteration_done(op, ret); 138bd48bde8SPaolo Bonzini } 139bd48bde8SPaolo Bonzini 140bd48bde8SPaolo Bonzini static void mirror_read_complete(void *opaque, int ret) 141bd48bde8SPaolo Bonzini { 142bd48bde8SPaolo Bonzini MirrorOp *op = opaque; 143bd48bde8SPaolo Bonzini MirrorBlockJob *s = op->s; 144bd48bde8SPaolo Bonzini if (ret < 0) { 145bd48bde8SPaolo Bonzini BlockErrorAction action; 146bd48bde8SPaolo Bonzini 14720dca810SJohn Snow bdrv_set_dirty_bitmap(s->dirty_bitmap, op->sector_num, op->nb_sectors); 148bd48bde8SPaolo Bonzini action = mirror_error_action(s, true, -ret); 149a589569fSWenchao Xia if (action == BLOCK_ERROR_ACTION_REPORT && s->ret >= 0) { 150bd48bde8SPaolo Bonzini s->ret = ret; 151bd48bde8SPaolo Bonzini } 152bd48bde8SPaolo Bonzini 153bd48bde8SPaolo Bonzini mirror_iteration_done(op, ret); 154bd48bde8SPaolo Bonzini return; 155bd48bde8SPaolo Bonzini } 156bd48bde8SPaolo Bonzini bdrv_aio_writev(s->target, op->sector_num, &op->qiov, op->nb_sectors, 157bd48bde8SPaolo Bonzini mirror_write_complete, op); 158bd48bde8SPaolo Bonzini } 159bd48bde8SPaolo Bonzini 160cc8c9d6cSPaolo Bonzini static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s) 161893f7ebaSPaolo Bonzini { 162893f7ebaSPaolo Bonzini BlockDriverState *source = s->common.bs; 163402a4741SPaolo Bonzini int nb_sectors, sectors_per_chunk, nb_chunks; 164884fea4eSPaolo Bonzini int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector; 1656d0de8ebSStefan Hajnoczi uint64_t delay_ns = 0; 166bd48bde8SPaolo Bonzini MirrorOp *op; 167893f7ebaSPaolo Bonzini 1688f0720ecSPaolo Bonzini s->sector_num = hbitmap_iter_next(&s->hbi); 1698f0720ecSPaolo Bonzini if (s->sector_num < 0) { 17020dca810SJohn Snow bdrv_dirty_iter_init(s->dirty_bitmap, &s->hbi); 1718f0720ecSPaolo Bonzini s->sector_num = hbitmap_iter_next(&s->hbi); 17220dca810SJohn Snow trace_mirror_restart_iter(s, bdrv_get_dirty_count(s->dirty_bitmap)); 1738f0720ecSPaolo Bonzini assert(s->sector_num >= 0); 1748f0720ecSPaolo Bonzini } 1758f0720ecSPaolo Bonzini 176402a4741SPaolo Bonzini hbitmap_next_sector = s->sector_num; 177b812f671SPaolo Bonzini sector_num = s->sector_num; 178884fea4eSPaolo Bonzini sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS; 179b21c7652SMax Reitz end = s->bdev_length / BDRV_SECTOR_SIZE; 180402a4741SPaolo Bonzini 181884fea4eSPaolo Bonzini /* Extend the QEMUIOVector to include all adjacent blocks that will 182884fea4eSPaolo Bonzini * be copied in this operation. 183884fea4eSPaolo Bonzini * 184884fea4eSPaolo Bonzini * We have to do this if we have no backing file yet in the destination, 185884fea4eSPaolo Bonzini * and the cluster size is very large. Then we need to do COW ourselves. 186884fea4eSPaolo Bonzini * The first time a cluster is copied, copy it entirely. Note that, 187884fea4eSPaolo Bonzini * because both the granularity and the cluster size are powers of two, 188884fea4eSPaolo Bonzini * the number of sectors to copy cannot exceed one cluster. 189884fea4eSPaolo Bonzini * 190884fea4eSPaolo Bonzini * We also want to extend the QEMUIOVector to include more adjacent 191884fea4eSPaolo Bonzini * dirty blocks if possible, to limit the number of I/O operations and 192884fea4eSPaolo Bonzini * run efficiently even with a small granularity. 193402a4741SPaolo Bonzini */ 194884fea4eSPaolo Bonzini nb_chunks = 0; 195884fea4eSPaolo Bonzini nb_sectors = 0; 196884fea4eSPaolo Bonzini next_sector = sector_num; 197884fea4eSPaolo Bonzini next_chunk = sector_num / sectors_per_chunk; 198402a4741SPaolo Bonzini 199402a4741SPaolo Bonzini /* Wait for I/O to this cluster (from a previous iteration) to be done. */ 200884fea4eSPaolo Bonzini while (test_bit(next_chunk, s->in_flight_bitmap)) { 201402a4741SPaolo Bonzini trace_mirror_yield_in_flight(s, sector_num, s->in_flight); 202402a4741SPaolo Bonzini qemu_coroutine_yield(); 203b812f671SPaolo Bonzini } 204b812f671SPaolo Bonzini 205884fea4eSPaolo Bonzini do { 206884fea4eSPaolo Bonzini int added_sectors, added_chunks; 207884fea4eSPaolo Bonzini 208e4654d2dSFam Zheng if (!bdrv_get_dirty(source, s->dirty_bitmap, next_sector) || 209884fea4eSPaolo Bonzini test_bit(next_chunk, s->in_flight_bitmap)) { 210884fea4eSPaolo Bonzini assert(nb_sectors > 0); 211884fea4eSPaolo Bonzini break; 212884fea4eSPaolo Bonzini } 213884fea4eSPaolo Bonzini 214884fea4eSPaolo Bonzini added_sectors = sectors_per_chunk; 215884fea4eSPaolo Bonzini if (s->cow_bitmap && !test_bit(next_chunk, s->cow_bitmap)) { 216884fea4eSPaolo Bonzini bdrv_round_to_clusters(s->target, 217884fea4eSPaolo Bonzini next_sector, added_sectors, 218884fea4eSPaolo Bonzini &next_sector, &added_sectors); 219884fea4eSPaolo Bonzini 220884fea4eSPaolo Bonzini /* On the first iteration, the rounding may make us copy 221884fea4eSPaolo Bonzini * sectors before the first dirty one. 222884fea4eSPaolo Bonzini */ 223884fea4eSPaolo Bonzini if (next_sector < sector_num) { 224884fea4eSPaolo Bonzini assert(nb_sectors == 0); 225884fea4eSPaolo Bonzini sector_num = next_sector; 226884fea4eSPaolo Bonzini next_chunk = next_sector / sectors_per_chunk; 227884fea4eSPaolo Bonzini } 228884fea4eSPaolo Bonzini } 229884fea4eSPaolo Bonzini 230884fea4eSPaolo Bonzini added_sectors = MIN(added_sectors, end - (sector_num + nb_sectors)); 231884fea4eSPaolo Bonzini added_chunks = (added_sectors + sectors_per_chunk - 1) / sectors_per_chunk; 232884fea4eSPaolo Bonzini 233884fea4eSPaolo Bonzini /* When doing COW, it may happen that there is not enough space for 234884fea4eSPaolo Bonzini * a full cluster. Wait if that is the case. 235884fea4eSPaolo Bonzini */ 236884fea4eSPaolo Bonzini while (nb_chunks == 0 && s->buf_free_count < added_chunks) { 237402a4741SPaolo Bonzini trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight); 238402a4741SPaolo Bonzini qemu_coroutine_yield(); 239402a4741SPaolo Bonzini } 240884fea4eSPaolo Bonzini if (s->buf_free_count < nb_chunks + added_chunks) { 241884fea4eSPaolo Bonzini trace_mirror_break_buf_busy(s, nb_chunks, s->in_flight); 242884fea4eSPaolo Bonzini break; 243884fea4eSPaolo Bonzini } 244402a4741SPaolo Bonzini 245402a4741SPaolo Bonzini /* We have enough free space to copy these sectors. */ 246884fea4eSPaolo Bonzini bitmap_set(s->in_flight_bitmap, next_chunk, added_chunks); 247884fea4eSPaolo Bonzini 248884fea4eSPaolo Bonzini nb_sectors += added_sectors; 249884fea4eSPaolo Bonzini nb_chunks += added_chunks; 250884fea4eSPaolo Bonzini next_sector += added_sectors; 251884fea4eSPaolo Bonzini next_chunk += added_chunks; 252cc8c9d6cSPaolo Bonzini if (!s->synced && s->common.speed) { 253cc8c9d6cSPaolo Bonzini delay_ns = ratelimit_calculate_delay(&s->limit, added_sectors); 254cc8c9d6cSPaolo Bonzini } 255cc8c9d6cSPaolo Bonzini } while (delay_ns == 0 && next_sector < end); 256bd48bde8SPaolo Bonzini 257bd48bde8SPaolo Bonzini /* Allocate a MirrorOp that is used as an AIO callback. */ 258bd48bde8SPaolo Bonzini op = g_slice_new(MirrorOp); 259bd48bde8SPaolo Bonzini op->s = s; 260bd48bde8SPaolo Bonzini op->sector_num = sector_num; 261bd48bde8SPaolo Bonzini op->nb_sectors = nb_sectors; 262402a4741SPaolo Bonzini 263402a4741SPaolo Bonzini /* Now make a QEMUIOVector taking enough granularity-sized chunks 264402a4741SPaolo Bonzini * from s->buf_free. 265402a4741SPaolo Bonzini */ 266402a4741SPaolo Bonzini qemu_iovec_init(&op->qiov, nb_chunks); 267402a4741SPaolo Bonzini next_sector = sector_num; 268402a4741SPaolo Bonzini while (nb_chunks-- > 0) { 269402a4741SPaolo Bonzini MirrorBuffer *buf = QSIMPLEQ_FIRST(&s->buf_free); 2705a0f6fd5SKevin Wolf size_t remaining = (nb_sectors * BDRV_SECTOR_SIZE) - op->qiov.size; 2715a0f6fd5SKevin Wolf 272402a4741SPaolo Bonzini QSIMPLEQ_REMOVE_HEAD(&s->buf_free, next); 273402a4741SPaolo Bonzini s->buf_free_count--; 2745a0f6fd5SKevin Wolf qemu_iovec_add(&op->qiov, buf, MIN(s->granularity, remaining)); 275402a4741SPaolo Bonzini 276402a4741SPaolo Bonzini /* Advance the HBitmapIter in parallel, so that we do not examine 277402a4741SPaolo Bonzini * the same sector twice. 278402a4741SPaolo Bonzini */ 279e4654d2dSFam Zheng if (next_sector > hbitmap_next_sector 280e4654d2dSFam Zheng && bdrv_get_dirty(source, s->dirty_bitmap, next_sector)) { 281402a4741SPaolo Bonzini hbitmap_next_sector = hbitmap_iter_next(&s->hbi); 282402a4741SPaolo Bonzini } 283402a4741SPaolo Bonzini 284402a4741SPaolo Bonzini next_sector += sectors_per_chunk; 285402a4741SPaolo Bonzini } 286bd48bde8SPaolo Bonzini 28720dca810SJohn Snow bdrv_reset_dirty_bitmap(s->dirty_bitmap, sector_num, nb_sectors); 288893f7ebaSPaolo Bonzini 289893f7ebaSPaolo Bonzini /* Copy the dirty cluster. */ 290bd48bde8SPaolo Bonzini s->in_flight++; 291b21c7652SMax Reitz s->sectors_in_flight += nb_sectors; 292b812f671SPaolo Bonzini trace_mirror_one_iteration(s, sector_num, nb_sectors); 293bd48bde8SPaolo Bonzini bdrv_aio_readv(source, sector_num, &op->qiov, nb_sectors, 294bd48bde8SPaolo Bonzini mirror_read_complete, op); 295cc8c9d6cSPaolo Bonzini return delay_ns; 296893f7ebaSPaolo Bonzini } 297b952b558SPaolo Bonzini 298402a4741SPaolo Bonzini static void mirror_free_init(MirrorBlockJob *s) 299402a4741SPaolo Bonzini { 300402a4741SPaolo Bonzini int granularity = s->granularity; 301402a4741SPaolo Bonzini size_t buf_size = s->buf_size; 302402a4741SPaolo Bonzini uint8_t *buf = s->buf; 303402a4741SPaolo Bonzini 304402a4741SPaolo Bonzini assert(s->buf_free_count == 0); 305402a4741SPaolo Bonzini QSIMPLEQ_INIT(&s->buf_free); 306402a4741SPaolo Bonzini while (buf_size != 0) { 307402a4741SPaolo Bonzini MirrorBuffer *cur = (MirrorBuffer *)buf; 308402a4741SPaolo Bonzini QSIMPLEQ_INSERT_TAIL(&s->buf_free, cur, next); 309402a4741SPaolo Bonzini s->buf_free_count++; 310402a4741SPaolo Bonzini buf_size -= granularity; 311402a4741SPaolo Bonzini buf += granularity; 312402a4741SPaolo Bonzini } 313402a4741SPaolo Bonzini } 314402a4741SPaolo Bonzini 315bd48bde8SPaolo Bonzini static void mirror_drain(MirrorBlockJob *s) 316bd48bde8SPaolo Bonzini { 317bd48bde8SPaolo Bonzini while (s->in_flight > 0) { 318bd48bde8SPaolo Bonzini qemu_coroutine_yield(); 319bd48bde8SPaolo Bonzini } 320893f7ebaSPaolo Bonzini } 321893f7ebaSPaolo Bonzini 3225a7e7a0bSStefan Hajnoczi typedef struct { 3235a7e7a0bSStefan Hajnoczi int ret; 3245a7e7a0bSStefan Hajnoczi } MirrorExitData; 3255a7e7a0bSStefan Hajnoczi 3265a7e7a0bSStefan Hajnoczi static void mirror_exit(BlockJob *job, void *opaque) 3275a7e7a0bSStefan Hajnoczi { 3285a7e7a0bSStefan Hajnoczi MirrorBlockJob *s = container_of(job, MirrorBlockJob, common); 3295a7e7a0bSStefan Hajnoczi MirrorExitData *data = opaque; 3305a7e7a0bSStefan Hajnoczi AioContext *replace_aio_context = NULL; 3315a7e7a0bSStefan Hajnoczi 3325a7e7a0bSStefan Hajnoczi if (s->to_replace) { 3335a7e7a0bSStefan Hajnoczi replace_aio_context = bdrv_get_aio_context(s->to_replace); 3345a7e7a0bSStefan Hajnoczi aio_context_acquire(replace_aio_context); 3355a7e7a0bSStefan Hajnoczi } 3365a7e7a0bSStefan Hajnoczi 3375a7e7a0bSStefan Hajnoczi if (s->should_complete && data->ret == 0) { 3385a7e7a0bSStefan Hajnoczi BlockDriverState *to_replace = s->common.bs; 3395a7e7a0bSStefan Hajnoczi if (s->to_replace) { 3405a7e7a0bSStefan Hajnoczi to_replace = s->to_replace; 3415a7e7a0bSStefan Hajnoczi } 3425a7e7a0bSStefan Hajnoczi if (bdrv_get_flags(s->target) != bdrv_get_flags(to_replace)) { 3435a7e7a0bSStefan Hajnoczi bdrv_reopen(s->target, bdrv_get_flags(to_replace), NULL); 3445a7e7a0bSStefan Hajnoczi } 3455a7e7a0bSStefan Hajnoczi bdrv_swap(s->target, to_replace); 3465a7e7a0bSStefan Hajnoczi if (s->common.driver->job_type == BLOCK_JOB_TYPE_COMMIT) { 3475a7e7a0bSStefan Hajnoczi /* drop the bs loop chain formed by the swap: break the loop then 3485a7e7a0bSStefan Hajnoczi * trigger the unref from the top one */ 3495a7e7a0bSStefan Hajnoczi BlockDriverState *p = s->base->backing_hd; 3505a7e7a0bSStefan Hajnoczi bdrv_set_backing_hd(s->base, NULL); 3515a7e7a0bSStefan Hajnoczi bdrv_unref(p); 3525a7e7a0bSStefan Hajnoczi } 3535a7e7a0bSStefan Hajnoczi } 3545a7e7a0bSStefan Hajnoczi if (s->to_replace) { 3555a7e7a0bSStefan Hajnoczi bdrv_op_unblock_all(s->to_replace, s->replace_blocker); 3565a7e7a0bSStefan Hajnoczi error_free(s->replace_blocker); 3575a7e7a0bSStefan Hajnoczi bdrv_unref(s->to_replace); 3585a7e7a0bSStefan Hajnoczi } 3595a7e7a0bSStefan Hajnoczi if (replace_aio_context) { 3605a7e7a0bSStefan Hajnoczi aio_context_release(replace_aio_context); 3615a7e7a0bSStefan Hajnoczi } 3625a7e7a0bSStefan Hajnoczi g_free(s->replaces); 3635a7e7a0bSStefan Hajnoczi bdrv_unref(s->target); 3645a7e7a0bSStefan Hajnoczi block_job_completed(&s->common, data->ret); 3655a7e7a0bSStefan Hajnoczi g_free(data); 3665a7e7a0bSStefan Hajnoczi } 3675a7e7a0bSStefan Hajnoczi 368893f7ebaSPaolo Bonzini static void coroutine_fn mirror_run(void *opaque) 369893f7ebaSPaolo Bonzini { 370893f7ebaSPaolo Bonzini MirrorBlockJob *s = opaque; 3715a7e7a0bSStefan Hajnoczi MirrorExitData *data; 372893f7ebaSPaolo Bonzini BlockDriverState *bs = s->common.bs; 373eee13dfeSPaolo Bonzini int64_t sector_num, end, sectors_per_chunk, length; 374bd48bde8SPaolo Bonzini uint64_t last_pause_ns; 375b812f671SPaolo Bonzini BlockDriverInfo bdi; 3761d33936eSJeff Cody char backing_filename[2]; /* we only need 2 characters because we are only 3771d33936eSJeff Cody checking for a NULL string */ 378893f7ebaSPaolo Bonzini int ret = 0; 379893f7ebaSPaolo Bonzini int n; 380893f7ebaSPaolo Bonzini 381893f7ebaSPaolo Bonzini if (block_job_is_cancelled(&s->common)) { 382893f7ebaSPaolo Bonzini goto immediate_exit; 383893f7ebaSPaolo Bonzini } 384893f7ebaSPaolo Bonzini 385b21c7652SMax Reitz s->bdev_length = bdrv_getlength(bs); 386b21c7652SMax Reitz if (s->bdev_length < 0) { 387b21c7652SMax Reitz ret = s->bdev_length; 388373df5b1SFam Zheng goto immediate_exit; 389b21c7652SMax Reitz } else if (s->bdev_length == 0) { 3909e48b025SFam Zheng /* Report BLOCK_JOB_READY and wait for complete. */ 3919e48b025SFam Zheng block_job_event_ready(&s->common); 3929e48b025SFam Zheng s->synced = true; 3939e48b025SFam Zheng while (!block_job_is_cancelled(&s->common) && !s->should_complete) { 3949e48b025SFam Zheng block_job_yield(&s->common); 3959e48b025SFam Zheng } 3969e48b025SFam Zheng s->common.cancelled = false; 3979e48b025SFam Zheng goto immediate_exit; 398893f7ebaSPaolo Bonzini } 399893f7ebaSPaolo Bonzini 400b21c7652SMax Reitz length = DIV_ROUND_UP(s->bdev_length, s->granularity); 401402a4741SPaolo Bonzini s->in_flight_bitmap = bitmap_new(length); 402402a4741SPaolo Bonzini 403b812f671SPaolo Bonzini /* If we have no backing file yet in the destination, we cannot let 404b812f671SPaolo Bonzini * the destination do COW. Instead, we copy sectors around the 405b812f671SPaolo Bonzini * dirty data if needed. We need a bitmap to do that. 406b812f671SPaolo Bonzini */ 407b812f671SPaolo Bonzini bdrv_get_backing_filename(s->target, backing_filename, 408b812f671SPaolo Bonzini sizeof(backing_filename)); 409b812f671SPaolo Bonzini if (backing_filename[0] && !s->target->backing_hd) { 410c3cc95bdSFam Zheng ret = bdrv_get_info(s->target, &bdi); 411c3cc95bdSFam Zheng if (ret < 0) { 412c3cc95bdSFam Zheng goto immediate_exit; 413c3cc95bdSFam Zheng } 414eee13dfeSPaolo Bonzini if (s->granularity < bdi.cluster_size) { 41508e4ed6cSPaolo Bonzini s->buf_size = MAX(s->buf_size, bdi.cluster_size); 416b812f671SPaolo Bonzini s->cow_bitmap = bitmap_new(length); 417b812f671SPaolo Bonzini } 418b812f671SPaolo Bonzini } 419b812f671SPaolo Bonzini 420b21c7652SMax Reitz end = s->bdev_length / BDRV_SECTOR_SIZE; 4217504edf4SKevin Wolf s->buf = qemu_try_blockalign(bs, s->buf_size); 4227504edf4SKevin Wolf if (s->buf == NULL) { 4237504edf4SKevin Wolf ret = -ENOMEM; 4247504edf4SKevin Wolf goto immediate_exit; 4257504edf4SKevin Wolf } 4267504edf4SKevin Wolf 427eee13dfeSPaolo Bonzini sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS; 428402a4741SPaolo Bonzini mirror_free_init(s); 429893f7ebaSPaolo Bonzini 43003544a6eSFam Zheng if (!s->is_none_mode) { 431893f7ebaSPaolo Bonzini /* First part, loop on the sectors and initialize the dirty bitmap. */ 4325bc361b8SFam Zheng BlockDriverState *base = s->base; 433893f7ebaSPaolo Bonzini for (sector_num = 0; sector_num < end; ) { 434eee13dfeSPaolo Bonzini int64_t next = (sector_num | (sectors_per_chunk - 1)) + 1; 4354f578637SPaolo Bonzini ret = bdrv_is_allocated_above(bs, base, 436893f7ebaSPaolo Bonzini sector_num, next - sector_num, &n); 437893f7ebaSPaolo Bonzini 438893f7ebaSPaolo Bonzini if (ret < 0) { 439893f7ebaSPaolo Bonzini goto immediate_exit; 440893f7ebaSPaolo Bonzini } 441893f7ebaSPaolo Bonzini 442893f7ebaSPaolo Bonzini assert(n > 0); 443893f7ebaSPaolo Bonzini if (ret == 1) { 44420dca810SJohn Snow bdrv_set_dirty_bitmap(s->dirty_bitmap, sector_num, n); 445893f7ebaSPaolo Bonzini sector_num = next; 446893f7ebaSPaolo Bonzini } else { 447893f7ebaSPaolo Bonzini sector_num += n; 448893f7ebaSPaolo Bonzini } 449893f7ebaSPaolo Bonzini } 450893f7ebaSPaolo Bonzini } 451893f7ebaSPaolo Bonzini 45220dca810SJohn Snow bdrv_dirty_iter_init(s->dirty_bitmap, &s->hbi); 453bc72ad67SAlex Bligh last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 454893f7ebaSPaolo Bonzini for (;;) { 455cc8c9d6cSPaolo Bonzini uint64_t delay_ns = 0; 456893f7ebaSPaolo Bonzini int64_t cnt; 457893f7ebaSPaolo Bonzini bool should_complete; 458893f7ebaSPaolo Bonzini 459bd48bde8SPaolo Bonzini if (s->ret < 0) { 460bd48bde8SPaolo Bonzini ret = s->ret; 461893f7ebaSPaolo Bonzini goto immediate_exit; 462893f7ebaSPaolo Bonzini } 463bd48bde8SPaolo Bonzini 46420dca810SJohn Snow cnt = bdrv_get_dirty_count(s->dirty_bitmap); 465b21c7652SMax Reitz /* s->common.offset contains the number of bytes already processed so 466b21c7652SMax Reitz * far, cnt is the number of dirty sectors remaining and 467b21c7652SMax Reitz * s->sectors_in_flight is the number of sectors currently being 468b21c7652SMax Reitz * processed; together those are the current total operation length */ 469b21c7652SMax Reitz s->common.len = s->common.offset + 470b21c7652SMax Reitz (cnt + s->sectors_in_flight) * BDRV_SECTOR_SIZE; 471bd48bde8SPaolo Bonzini 472bd48bde8SPaolo Bonzini /* Note that even when no rate limit is applied we need to yield 473a7282330SFam Zheng * periodically with no pending I/O so that bdrv_drain_all() returns. 474bd48bde8SPaolo Bonzini * We do so every SLICE_TIME nanoseconds, or when there is an error, 475bd48bde8SPaolo Bonzini * or when the source is clean, whichever comes first. 476bd48bde8SPaolo Bonzini */ 477bc72ad67SAlex Bligh if (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - last_pause_ns < SLICE_TIME && 478bd48bde8SPaolo Bonzini s->common.iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 479402a4741SPaolo Bonzini if (s->in_flight == MAX_IN_FLIGHT || s->buf_free_count == 0 || 480402a4741SPaolo Bonzini (cnt == 0 && s->in_flight > 0)) { 481402a4741SPaolo Bonzini trace_mirror_yield(s, s->in_flight, s->buf_free_count, cnt); 482bd48bde8SPaolo Bonzini qemu_coroutine_yield(); 483bd48bde8SPaolo Bonzini continue; 484bd48bde8SPaolo Bonzini } else if (cnt != 0) { 485cc8c9d6cSPaolo Bonzini delay_ns = mirror_iteration(s); 486893f7ebaSPaolo Bonzini } 487cc8c9d6cSPaolo Bonzini } 488893f7ebaSPaolo Bonzini 489893f7ebaSPaolo Bonzini should_complete = false; 490bd48bde8SPaolo Bonzini if (s->in_flight == 0 && cnt == 0) { 491893f7ebaSPaolo Bonzini trace_mirror_before_flush(s); 492893f7ebaSPaolo Bonzini ret = bdrv_flush(s->target); 493893f7ebaSPaolo Bonzini if (ret < 0) { 494a589569fSWenchao Xia if (mirror_error_action(s, false, -ret) == 495a589569fSWenchao Xia BLOCK_ERROR_ACTION_REPORT) { 496893f7ebaSPaolo Bonzini goto immediate_exit; 497893f7ebaSPaolo Bonzini } 498b952b558SPaolo Bonzini } else { 499893f7ebaSPaolo Bonzini /* We're out of the streaming phase. From now on, if the job 500893f7ebaSPaolo Bonzini * is cancelled we will actually complete all pending I/O and 501893f7ebaSPaolo Bonzini * report completion. This way, block-job-cancel will leave 502893f7ebaSPaolo Bonzini * the target in a consistent state. 503893f7ebaSPaolo Bonzini */ 504d63ffd87SPaolo Bonzini if (!s->synced) { 505bcada37bSWenchao Xia block_job_event_ready(&s->common); 506d63ffd87SPaolo Bonzini s->synced = true; 507d63ffd87SPaolo Bonzini } 508d63ffd87SPaolo Bonzini 509d63ffd87SPaolo Bonzini should_complete = s->should_complete || 510d63ffd87SPaolo Bonzini block_job_is_cancelled(&s->common); 51120dca810SJohn Snow cnt = bdrv_get_dirty_count(s->dirty_bitmap); 512893f7ebaSPaolo Bonzini } 513b952b558SPaolo Bonzini } 514893f7ebaSPaolo Bonzini 515893f7ebaSPaolo Bonzini if (cnt == 0 && should_complete) { 516893f7ebaSPaolo Bonzini /* The dirty bitmap is not updated while operations are pending. 517893f7ebaSPaolo Bonzini * If we're about to exit, wait for pending operations before 518893f7ebaSPaolo Bonzini * calling bdrv_get_dirty_count(bs), or we may exit while the 519893f7ebaSPaolo Bonzini * source has dirty data to copy! 520893f7ebaSPaolo Bonzini * 521893f7ebaSPaolo Bonzini * Note that I/O can be submitted by the guest while 522893f7ebaSPaolo Bonzini * mirror_populate runs. 523893f7ebaSPaolo Bonzini */ 524893f7ebaSPaolo Bonzini trace_mirror_before_drain(s, cnt); 5255a7e7a0bSStefan Hajnoczi bdrv_drain(bs); 52620dca810SJohn Snow cnt = bdrv_get_dirty_count(s->dirty_bitmap); 527893f7ebaSPaolo Bonzini } 528893f7ebaSPaolo Bonzini 529893f7ebaSPaolo Bonzini ret = 0; 530cc8c9d6cSPaolo Bonzini trace_mirror_before_sleep(s, cnt, s->synced, delay_ns); 531d63ffd87SPaolo Bonzini if (!s->synced) { 5327483d1e5SAlex Bligh block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns); 533893f7ebaSPaolo Bonzini if (block_job_is_cancelled(&s->common)) { 534893f7ebaSPaolo Bonzini break; 535893f7ebaSPaolo Bonzini } 536893f7ebaSPaolo Bonzini } else if (!should_complete) { 537bd48bde8SPaolo Bonzini delay_ns = (s->in_flight == 0 && cnt == 0 ? SLICE_TIME : 0); 5387483d1e5SAlex Bligh block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns); 539893f7ebaSPaolo Bonzini } else if (cnt == 0) { 540893f7ebaSPaolo Bonzini /* The two disks are in sync. Exit and report successful 541893f7ebaSPaolo Bonzini * completion. 542893f7ebaSPaolo Bonzini */ 543893f7ebaSPaolo Bonzini assert(QLIST_EMPTY(&bs->tracked_requests)); 544893f7ebaSPaolo Bonzini s->common.cancelled = false; 545893f7ebaSPaolo Bonzini break; 546893f7ebaSPaolo Bonzini } 547bc72ad67SAlex Bligh last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); 548893f7ebaSPaolo Bonzini } 549893f7ebaSPaolo Bonzini 550893f7ebaSPaolo Bonzini immediate_exit: 551bd48bde8SPaolo Bonzini if (s->in_flight > 0) { 552bd48bde8SPaolo Bonzini /* We get here only if something went wrong. Either the job failed, 553bd48bde8SPaolo Bonzini * or it was cancelled prematurely so that we do not guarantee that 554bd48bde8SPaolo Bonzini * the target is a copy of the source. 555bd48bde8SPaolo Bonzini */ 556bd48bde8SPaolo Bonzini assert(ret < 0 || (!s->synced && block_job_is_cancelled(&s->common))); 557bd48bde8SPaolo Bonzini mirror_drain(s); 558bd48bde8SPaolo Bonzini } 559bd48bde8SPaolo Bonzini 560bd48bde8SPaolo Bonzini assert(s->in_flight == 0); 5617191bf31SMarkus Armbruster qemu_vfree(s->buf); 562b812f671SPaolo Bonzini g_free(s->cow_bitmap); 563402a4741SPaolo Bonzini g_free(s->in_flight_bitmap); 564e4654d2dSFam Zheng bdrv_release_dirty_bitmap(bs, s->dirty_bitmap); 565b952b558SPaolo Bonzini bdrv_iostatus_disable(s->target); 5665a7e7a0bSStefan Hajnoczi 5675a7e7a0bSStefan Hajnoczi data = g_malloc(sizeof(*data)); 5685a7e7a0bSStefan Hajnoczi data->ret = ret; 5695a7e7a0bSStefan Hajnoczi block_job_defer_to_main_loop(&s->common, mirror_exit, data); 570893f7ebaSPaolo Bonzini } 571893f7ebaSPaolo Bonzini 572893f7ebaSPaolo Bonzini static void mirror_set_speed(BlockJob *job, int64_t speed, Error **errp) 573893f7ebaSPaolo Bonzini { 574893f7ebaSPaolo Bonzini MirrorBlockJob *s = container_of(job, MirrorBlockJob, common); 575893f7ebaSPaolo Bonzini 576893f7ebaSPaolo Bonzini if (speed < 0) { 577c6bd8c70SMarkus Armbruster error_setg(errp, QERR_INVALID_PARAMETER, "speed"); 578893f7ebaSPaolo Bonzini return; 579893f7ebaSPaolo Bonzini } 580893f7ebaSPaolo Bonzini ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME); 581893f7ebaSPaolo Bonzini } 582893f7ebaSPaolo Bonzini 583b952b558SPaolo Bonzini static void mirror_iostatus_reset(BlockJob *job) 584b952b558SPaolo Bonzini { 585b952b558SPaolo Bonzini MirrorBlockJob *s = container_of(job, MirrorBlockJob, common); 586b952b558SPaolo Bonzini 587b952b558SPaolo Bonzini bdrv_iostatus_reset(s->target); 588b952b558SPaolo Bonzini } 589b952b558SPaolo Bonzini 590d63ffd87SPaolo Bonzini static void mirror_complete(BlockJob *job, Error **errp) 591d63ffd87SPaolo Bonzini { 592d63ffd87SPaolo Bonzini MirrorBlockJob *s = container_of(job, MirrorBlockJob, common); 59334b5d2c6SMax Reitz Error *local_err = NULL; 594d63ffd87SPaolo Bonzini int ret; 595d63ffd87SPaolo Bonzini 59634b5d2c6SMax Reitz ret = bdrv_open_backing_file(s->target, NULL, &local_err); 597d63ffd87SPaolo Bonzini if (ret < 0) { 59834b5d2c6SMax Reitz error_propagate(errp, local_err); 599d63ffd87SPaolo Bonzini return; 600d63ffd87SPaolo Bonzini } 601d63ffd87SPaolo Bonzini if (!s->synced) { 602c6bd8c70SMarkus Armbruster error_setg(errp, QERR_BLOCK_JOB_NOT_READY, 603bfb197e0SMarkus Armbruster bdrv_get_device_name(job->bs)); 604d63ffd87SPaolo Bonzini return; 605d63ffd87SPaolo Bonzini } 606d63ffd87SPaolo Bonzini 60709158f00SBenoît Canet /* check the target bs is not blocked and block all operations on it */ 60809158f00SBenoît Canet if (s->replaces) { 6095a7e7a0bSStefan Hajnoczi AioContext *replace_aio_context; 6105a7e7a0bSStefan Hajnoczi 61109158f00SBenoît Canet s->to_replace = check_to_replace_node(s->replaces, &local_err); 61209158f00SBenoît Canet if (!s->to_replace) { 61309158f00SBenoît Canet error_propagate(errp, local_err); 61409158f00SBenoît Canet return; 61509158f00SBenoît Canet } 61609158f00SBenoît Canet 6175a7e7a0bSStefan Hajnoczi replace_aio_context = bdrv_get_aio_context(s->to_replace); 6185a7e7a0bSStefan Hajnoczi aio_context_acquire(replace_aio_context); 6195a7e7a0bSStefan Hajnoczi 62009158f00SBenoît Canet error_setg(&s->replace_blocker, 62109158f00SBenoît Canet "block device is in use by block-job-complete"); 62209158f00SBenoît Canet bdrv_op_block_all(s->to_replace, s->replace_blocker); 62309158f00SBenoît Canet bdrv_ref(s->to_replace); 6245a7e7a0bSStefan Hajnoczi 6255a7e7a0bSStefan Hajnoczi aio_context_release(replace_aio_context); 62609158f00SBenoît Canet } 62709158f00SBenoît Canet 628d63ffd87SPaolo Bonzini s->should_complete = true; 629751ebd76SFam Zheng block_job_enter(&s->common); 630d63ffd87SPaolo Bonzini } 631d63ffd87SPaolo Bonzini 6323fc4b10aSFam Zheng static const BlockJobDriver mirror_job_driver = { 633893f7ebaSPaolo Bonzini .instance_size = sizeof(MirrorBlockJob), 63479e14bf7SFam Zheng .job_type = BLOCK_JOB_TYPE_MIRROR, 635893f7ebaSPaolo Bonzini .set_speed = mirror_set_speed, 636b952b558SPaolo Bonzini .iostatus_reset= mirror_iostatus_reset, 637d63ffd87SPaolo Bonzini .complete = mirror_complete, 638893f7ebaSPaolo Bonzini }; 639893f7ebaSPaolo Bonzini 64003544a6eSFam Zheng static const BlockJobDriver commit_active_job_driver = { 64103544a6eSFam Zheng .instance_size = sizeof(MirrorBlockJob), 64203544a6eSFam Zheng .job_type = BLOCK_JOB_TYPE_COMMIT, 64303544a6eSFam Zheng .set_speed = mirror_set_speed, 64403544a6eSFam Zheng .iostatus_reset 64503544a6eSFam Zheng = mirror_iostatus_reset, 64603544a6eSFam Zheng .complete = mirror_complete, 64703544a6eSFam Zheng }; 64803544a6eSFam Zheng 64903544a6eSFam Zheng static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target, 65009158f00SBenoît Canet const char *replaces, 6515fba6c0eSJohn Snow int64_t speed, uint32_t granularity, 65203544a6eSFam Zheng int64_t buf_size, 65303544a6eSFam Zheng BlockdevOnError on_source_error, 654b952b558SPaolo Bonzini BlockdevOnError on_target_error, 655097310b5SMarkus Armbruster BlockCompletionFunc *cb, 65603544a6eSFam Zheng void *opaque, Error **errp, 65703544a6eSFam Zheng const BlockJobDriver *driver, 65803544a6eSFam Zheng bool is_none_mode, BlockDriverState *base) 659893f7ebaSPaolo Bonzini { 660893f7ebaSPaolo Bonzini MirrorBlockJob *s; 661893f7ebaSPaolo Bonzini 662eee13dfeSPaolo Bonzini if (granularity == 0) { 663341ebc2fSJohn Snow granularity = bdrv_get_default_bitmap_granularity(target); 664eee13dfeSPaolo Bonzini } 665eee13dfeSPaolo Bonzini 666eee13dfeSPaolo Bonzini assert ((granularity & (granularity - 1)) == 0); 667eee13dfeSPaolo Bonzini 668b952b558SPaolo Bonzini if ((on_source_error == BLOCKDEV_ON_ERROR_STOP || 669b952b558SPaolo Bonzini on_source_error == BLOCKDEV_ON_ERROR_ENOSPC) && 670b952b558SPaolo Bonzini !bdrv_iostatus_is_enabled(bs)) { 671c6bd8c70SMarkus Armbruster error_setg(errp, QERR_INVALID_PARAMETER, "on-source-error"); 672b952b558SPaolo Bonzini return; 673b952b558SPaolo Bonzini } 674b952b558SPaolo Bonzini 6755bc361b8SFam Zheng 67603544a6eSFam Zheng s = block_job_create(driver, bs, speed, cb, opaque, errp); 677893f7ebaSPaolo Bonzini if (!s) { 678893f7ebaSPaolo Bonzini return; 679893f7ebaSPaolo Bonzini } 680893f7ebaSPaolo Bonzini 68109158f00SBenoît Canet s->replaces = g_strdup(replaces); 682b952b558SPaolo Bonzini s->on_source_error = on_source_error; 683b952b558SPaolo Bonzini s->on_target_error = on_target_error; 684893f7ebaSPaolo Bonzini s->target = target; 68503544a6eSFam Zheng s->is_none_mode = is_none_mode; 6865bc361b8SFam Zheng s->base = base; 687eee13dfeSPaolo Bonzini s->granularity = granularity; 68808e4ed6cSPaolo Bonzini s->buf_size = MAX(buf_size, granularity); 689b812f671SPaolo Bonzini 6900db6e54aSFam Zheng s->dirty_bitmap = bdrv_create_dirty_bitmap(bs, granularity, NULL, errp); 691b8afb520SFam Zheng if (!s->dirty_bitmap) { 692b8afb520SFam Zheng return; 693b8afb520SFam Zheng } 694893f7ebaSPaolo Bonzini bdrv_set_enable_write_cache(s->target, true); 695b952b558SPaolo Bonzini bdrv_set_on_error(s->target, on_target_error, on_target_error); 696b952b558SPaolo Bonzini bdrv_iostatus_enable(s->target); 697893f7ebaSPaolo Bonzini s->common.co = qemu_coroutine_create(mirror_run); 698893f7ebaSPaolo Bonzini trace_mirror_start(bs, s, s->common.co, opaque); 699893f7ebaSPaolo Bonzini qemu_coroutine_enter(s->common.co, s); 700893f7ebaSPaolo Bonzini } 70103544a6eSFam Zheng 70203544a6eSFam Zheng void mirror_start(BlockDriverState *bs, BlockDriverState *target, 70309158f00SBenoît Canet const char *replaces, 7045fba6c0eSJohn Snow int64_t speed, uint32_t granularity, int64_t buf_size, 70503544a6eSFam Zheng MirrorSyncMode mode, BlockdevOnError on_source_error, 70603544a6eSFam Zheng BlockdevOnError on_target_error, 707097310b5SMarkus Armbruster BlockCompletionFunc *cb, 70803544a6eSFam Zheng void *opaque, Error **errp) 70903544a6eSFam Zheng { 71003544a6eSFam Zheng bool is_none_mode; 71103544a6eSFam Zheng BlockDriverState *base; 71203544a6eSFam Zheng 713d58d8453SJohn Snow if (mode == MIRROR_SYNC_MODE_DIRTY_BITMAP) { 714d58d8453SJohn Snow error_setg(errp, "Sync mode 'dirty-bitmap' not supported"); 715d58d8453SJohn Snow return; 716d58d8453SJohn Snow } 71703544a6eSFam Zheng is_none_mode = mode == MIRROR_SYNC_MODE_NONE; 71803544a6eSFam Zheng base = mode == MIRROR_SYNC_MODE_TOP ? bs->backing_hd : NULL; 71909158f00SBenoît Canet mirror_start_job(bs, target, replaces, 72009158f00SBenoît Canet speed, granularity, buf_size, 72103544a6eSFam Zheng on_source_error, on_target_error, cb, opaque, errp, 72203544a6eSFam Zheng &mirror_job_driver, is_none_mode, base); 72303544a6eSFam Zheng } 72403544a6eSFam Zheng 72503544a6eSFam Zheng void commit_active_start(BlockDriverState *bs, BlockDriverState *base, 72603544a6eSFam Zheng int64_t speed, 72703544a6eSFam Zheng BlockdevOnError on_error, 728097310b5SMarkus Armbruster BlockCompletionFunc *cb, 72903544a6eSFam Zheng void *opaque, Error **errp) 73003544a6eSFam Zheng { 7314da83585SJeff Cody int64_t length, base_length; 7324da83585SJeff Cody int orig_base_flags; 73339a611a3SJeff Cody int ret; 734cc67f4d1SJeff Cody Error *local_err = NULL; 7354da83585SJeff Cody 7364da83585SJeff Cody orig_base_flags = bdrv_get_flags(base); 7374da83585SJeff Cody 73820a63d2cSFam Zheng if (bdrv_reopen(base, bs->open_flags, errp)) { 73920a63d2cSFam Zheng return; 74020a63d2cSFam Zheng } 7414da83585SJeff Cody 7424da83585SJeff Cody length = bdrv_getlength(bs); 7434da83585SJeff Cody if (length < 0) { 74439a611a3SJeff Cody error_setg_errno(errp, -length, 74539a611a3SJeff Cody "Unable to determine length of %s", bs->filename); 7464da83585SJeff Cody goto error_restore_flags; 7474da83585SJeff Cody } 7484da83585SJeff Cody 7494da83585SJeff Cody base_length = bdrv_getlength(base); 7504da83585SJeff Cody if (base_length < 0) { 75139a611a3SJeff Cody error_setg_errno(errp, -base_length, 75239a611a3SJeff Cody "Unable to determine length of %s", base->filename); 7534da83585SJeff Cody goto error_restore_flags; 7544da83585SJeff Cody } 7554da83585SJeff Cody 7564da83585SJeff Cody if (length > base_length) { 75739a611a3SJeff Cody ret = bdrv_truncate(base, length); 75839a611a3SJeff Cody if (ret < 0) { 75939a611a3SJeff Cody error_setg_errno(errp, -ret, 76039a611a3SJeff Cody "Top image %s is larger than base image %s, and " 7614da83585SJeff Cody "resize of base image failed", 7624da83585SJeff Cody bs->filename, base->filename); 7634da83585SJeff Cody goto error_restore_flags; 7644da83585SJeff Cody } 7654da83585SJeff Cody } 7664da83585SJeff Cody 76720a63d2cSFam Zheng bdrv_ref(base); 76809158f00SBenoît Canet mirror_start_job(bs, base, NULL, speed, 0, 0, 769cc67f4d1SJeff Cody on_error, on_error, cb, opaque, &local_err, 77003544a6eSFam Zheng &commit_active_job_driver, false, base); 7710fb6395cSMarkus Armbruster if (local_err) { 772cc67f4d1SJeff Cody error_propagate(errp, local_err); 7734da83585SJeff Cody goto error_restore_flags; 7744da83585SJeff Cody } 7754da83585SJeff Cody 7764da83585SJeff Cody return; 7774da83585SJeff Cody 7784da83585SJeff Cody error_restore_flags: 7794da83585SJeff Cody /* ignore error and errp for bdrv_reopen, because we want to propagate 7804da83585SJeff Cody * the original error */ 7814da83585SJeff Cody bdrv_reopen(base, orig_base_flags, NULL); 7824da83585SJeff Cody return; 78303544a6eSFam Zheng } 784