block/block-copy.c

   1 /*
   2  * block_copy API
   3  *
   4  * Copyright (C) 2013 Proxmox Server Solutions
   5  * Copyright (c) 2019 Virtuozzo International GmbH.
   6  *
   7  * Authors:
   8  *  Dietmar Maurer ([email protected])
   9  *  Vladimir Sementsov-Ogievskiy <[email protected]>
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  12  * See the COPYING file in the top-level directory.
  13  */
  14
  15 #include "qemu/osdep.h"
  16
  17 #include "trace.h"
  18 #include "qapi/error.h"
  19 #include "block/block-copy.h"
  20 #include "sysemu/block-backend.h"
  21 #include "qemu/units.h"
  22 #include "qemu/coroutine.h"
  23 #include "block/aio_task.h"
  24
  25 #define BLOCK_COPY_MAX_COPY_RANGE (16 * MiB)
  26 #define BLOCK_COPY_MAX_BUFFER (1 * MiB)
  27 #define BLOCK_COPY_MAX_MEM (128 * MiB)
  28 #define BLOCK_COPY_MAX_WORKERS 64
  29 #define BLOCK_COPY_SLICE_TIME 100000000ULL /* ns */
  30
  31 static coroutine_fn int block_copy_task_entry(AioTask *task);
  32
  33 typedef struct BlockCopyCallState {
  34     /* IN parameters. Initialized in block_copy_async() and never changed. */
  35     BlockCopyState *s;
  36     int64_t offset;
  37     int64_t bytes;
  38     int max_workers;
  39     int64_t max_chunk;
  40     bool ignore_ratelimit;
  41     BlockCopyAsyncCallbackFunc cb;
  42     void *cb_opaque;
  43
  44     /* Coroutine where async block-copy is running */
  45     Coroutine *co;
  46
  47     /* To reference all call states from BlockCopyState */
  48     QLIST_ENTRY(BlockCopyCallState) list;
  49
  50     /* State */
  51     int ret;
  52     bool finished;
  53     QemuCoSleepState *sleep_state;
  54     bool cancelled;
  55
  56     /* OUT parameters */
  57     bool error_is_read;
  58 } BlockCopyCallState;
  59
  60 typedef struct BlockCopyTask {
  61     AioTask task;
  62
  63     BlockCopyState *s;
  64     BlockCopyCallState *call_state;
  65     int64_t offset;
  66     int64_t bytes;
  67     bool zeroes;
  68     QLIST_ENTRY(BlockCopyTask) list;
  69     CoQueue wait_queue; /* coroutines blocked on this task */
  70 } BlockCopyTask;
  71
  72 static int64_t task_end(BlockCopyTask *task)
  73 {
  74     return task->offset + task->bytes;
  75 }
  76
  77 typedef struct BlockCopyState {
  78     /*
  79      * BdrvChild objects are not owned or managed by block-copy. They are
  80      * provided by block-copy user and user is responsible for appropriate
  81      * permissions on these children.
  82      */
  83     BdrvChild *source;
  84     BdrvChild *target;
  85     BdrvDirtyBitmap *copy_bitmap;
  86     int64_t in_flight_bytes;
  87     int64_t cluster_size;
  88     bool use_copy_range;
  89     int64_t copy_size;
  90     uint64_t len;
  91     QLIST_HEAD(, BlockCopyTask) tasks; /* All tasks from all block-copy calls */
  92     QLIST_HEAD(, BlockCopyCallState) calls;
  93
  94     BdrvRequestFlags write_flags;
  95
  96     /*
  97      * skip_unallocated:
  98      *
  99      * Used by sync=top jobs, which first scan the source node for unallocated
 100      * areas and clear them in the copy_bitmap.  During this process, the bitmap
 101      * is thus not fully initialized: It may still have bits set for areas that
 102      * are unallocated and should actually not be copied.
 103      *
 104      * This is indicated by skip_unallocated.
 105      *
 106      * In this case, block_copy() will query the source’s allocation status,
 107      * skip unallocated regions, clear them in the copy_bitmap, and invoke
 108      * block_copy_reset_unallocated() every time it does.
 109      */
 110     bool skip_unallocated;
 111
 112     ProgressMeter *progress;
 113
 114     SharedResource *mem;
 115
 116     uint64_t speed;
 117     RateLimit rate_limit;
 118 } BlockCopyState;
 119
 120 static BlockCopyTask *find_conflicting_task(BlockCopyState *s,
 121                                             int64_t offset, int64_t bytes)
 122 {
 123     BlockCopyTask *t;
 124
 125     QLIST_FOREACH(t, &s->tasks, list) {
 126         if (offset + bytes > t->offset && offset < t->offset + t->bytes) {
 127             return t;
 128         }
 129     }
 130
 131     return NULL;
 132 }
 133
 134 /*
 135  * If there are no intersecting tasks return false. Otherwise, wait for the
 136  * first found intersecting tasks to finish and return true.
 137  */
 138 static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t offset,
 139                                              int64_t bytes)
 140 {
 141     BlockCopyTask *task = find_conflicting_task(s, offset, bytes);
 142
 143     if (!task) {
 144         return false;
 145     }
 146
 147     qemu_co_queue_wait(&task->wait_queue, NULL);
 148
 149     return true;
 150 }
 151
 152 /*
 153  * Search for the first dirty area in offset/bytes range and create task at
 154  * the beginning of it.
 155  */
 156 static BlockCopyTask *block_copy_task_create(BlockCopyState *s,
 157                                              BlockCopyCallState *call_state,
 158                                              int64_t offset, int64_t bytes)
 159 {
 160     BlockCopyTask *task;
 161     int64_t max_chunk = MIN_NON_ZERO(s->copy_size, call_state->max_chunk);
 162
 163     if (!bdrv_dirty_bitmap_next_dirty_area(s->copy_bitmap,
 164                                            offset, offset + bytes,
 165                                            max_chunk, &offset, &bytes))
 166     {
 167         return NULL;
 168     }
 169
 170     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
 171     bytes = QEMU_ALIGN_UP(bytes, s->cluster_size);
 172
 173     /* region is dirty, so no existent tasks possible in it */
 174     assert(!find_conflicting_task(s, offset, bytes));
 175
 176     bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
 177     s->in_flight_bytes += bytes;
 178
 179     task = g_new(BlockCopyTask, 1);
 180     *task = (BlockCopyTask) {
 181         .task.func = block_copy_task_entry,
 182         .s = s,
 183         .call_state = call_state,
 184         .offset = offset,
 185         .bytes = bytes,
 186     };
 187     qemu_co_queue_init(&task->wait_queue);
 188     QLIST_INSERT_HEAD(&s->tasks, task, list);
 189
 190     return task;
 191 }
 192
 193 /*
 194  * block_copy_task_shrink
 195  *
 196  * Drop the tail of the task to be handled later. Set dirty bits back and
 197  * wake up all tasks waiting for us (may be some of them are not intersecting
 198  * with shrunk task)
 199  */
 200 static void coroutine_fn block_copy_task_shrink(BlockCopyTask *task,
 201                                                 int64_t new_bytes)
 202 {
 203     if (new_bytes == task->bytes) {
 204         return;
 205     }
 206
 207     assert(new_bytes > 0 && new_bytes < task->bytes);
 208
 209     task->s->in_flight_bytes -= task->bytes - new_bytes;
 210     bdrv_set_dirty_bitmap(task->s->copy_bitmap,
 211                           task->offset + new_bytes, task->bytes - new_bytes);
 212
 213     task->bytes = new_bytes;
 214     qemu_co_queue_restart_all(&task->wait_queue);
 215 }
 216
 217 static void coroutine_fn block_copy_task_end(BlockCopyTask *task, int ret)
 218 {
 219     task->s->in_flight_bytes -= task->bytes;
 220     if (ret < 0) {
 221         bdrv_set_dirty_bitmap(task->s->copy_bitmap, task->offset, task->bytes);
 222     }
 223     QLIST_REMOVE(task, list);
 224     qemu_co_queue_restart_all(&task->wait_queue);
 225 }
 226
 227 void block_copy_state_free(BlockCopyState *s)
 228 {
 229     if (!s) {
 230         return;
 231     }
 232
 233     bdrv_release_dirty_bitmap(s->copy_bitmap);
 234     shres_destroy(s->mem);
 235     g_free(s);
 236 }
 237
 238 static uint32_t block_copy_max_transfer(BdrvChild *source, BdrvChild *target)
 239 {
 240     return MIN_NON_ZERO(INT_MAX,
 241                         MIN_NON_ZERO(source->bs->bl.max_transfer,
 242                                      target->bs->bl.max_transfer));
 243 }
 244
 245 BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
 246                                      int64_t cluster_size, bool use_copy_range,
 247                                      BdrvRequestFlags write_flags, Error **errp)
 248 {
 249     BlockCopyState *s;
 250     BdrvDirtyBitmap *copy_bitmap;
 251
 252     copy_bitmap = bdrv_create_dirty_bitmap(source->bs, cluster_size, NULL,
 253                                            errp);
 254     if (!copy_bitmap) {
 255         return NULL;
 256     }
 257     bdrv_disable_dirty_bitmap(copy_bitmap);
 258
 259     s = g_new(BlockCopyState, 1);
 260     *s = (BlockCopyState) {
 261         .source = source,
 262         .target = target,
 263         .copy_bitmap = copy_bitmap,
 264         .cluster_size = cluster_size,
 265         .len = bdrv_dirty_bitmap_size(copy_bitmap),
 266         .write_flags = write_flags,
 267         .mem = shres_create(BLOCK_COPY_MAX_MEM),
 268     };
 269
 270     if (block_copy_max_transfer(source, target) < cluster_size) {
 271         /*
 272          * copy_range does not respect max_transfer. We don't want to bother
 273          * with requests smaller than block-copy cluster size, so fallback to
 274          * buffered copying (read and write respect max_transfer on their
 275          * behalf).
 276          */
 277         s->use_copy_range = false;
 278         s->copy_size = cluster_size;
 279     } else if (write_flags & BDRV_REQ_WRITE_COMPRESSED) {
 280         /* Compression supports only cluster-size writes and no copy-range. */
 281         s->use_copy_range = false;
 282         s->copy_size = cluster_size;
 283     } else {
 284         /*
 285          * We enable copy-range, but keep small copy_size, until first
 286          * successful copy_range (look at block_copy_do_copy).
 287          */
 288         s->use_copy_range = use_copy_range;
 289         s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
 290     }
 291
 292     QLIST_INIT(&s->tasks);
 293     QLIST_INIT(&s->calls);
 294
 295     return s;
 296 }
 297
 298 void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
 299 {
 300     s->progress = pm;
 301 }
 302
 303 /*
 304  * Takes ownership of @task
 305  *
 306  * If pool is NULL directly run the task, otherwise schedule it into the pool.
 307  *
 308  * Returns: task.func return code if pool is NULL
 309  *          otherwise -ECANCELED if pool status is bad
 310  *          otherwise 0 (successfully scheduled)
 311  */
 312 static coroutine_fn int block_copy_task_run(AioTaskPool *pool,
 313                                             BlockCopyTask *task)
 314 {
 315     if (!pool) {
 316         int ret = task->task.func(&task->task);
 317
 318         g_free(task);
 319         return ret;
 320     }
 321
 322     aio_task_pool_wait_slot(pool);
 323     if (aio_task_pool_status(pool) < 0) {
 324         co_put_to_shres(task->s->mem, task->bytes);
 325         block_copy_task_end(task, -ECANCELED);
 326         g_free(task);
 327         return -ECANCELED;
 328     }
 329
 330     aio_task_pool_start_task(pool, &task->task);
 331
 332     return 0;
 333 }
 334
 335 /*
 336  * block_copy_do_copy
 337  *
 338  * Do copy of cluster-aligned chunk. Requested region is allowed to exceed
 339  * s->len only to cover last cluster when s->len is not aligned to clusters.
 340  *
 341  * No sync here: nor bitmap neighter intersecting requests handling, only copy.
 342  *
 343  * Returns 0 on success.
 344  */
 345 static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
 346                                            int64_t offset, int64_t bytes,
 347                                            bool zeroes, bool *error_is_read)
 348 {
 349     int ret;
 350     int64_t nbytes = MIN(offset + bytes, s->len) - offset;
 351     void *bounce_buffer = NULL;
 352
 353     assert(offset >= 0 && bytes > 0 && INT64_MAX - offset >= bytes);
 354     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
 355     assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 356     assert(offset < s->len);
 357     assert(offset + bytes <= s->len ||
 358            offset + bytes == QEMU_ALIGN_UP(s->len, s->cluster_size));
 359     assert(nbytes < INT_MAX);
 360
 361     if (zeroes) {
 362         ret = bdrv_co_pwrite_zeroes(s->target, offset, nbytes, s->write_flags &
 363                                     ~BDRV_REQ_WRITE_COMPRESSED);
 364         if (ret < 0) {
 365             trace_block_copy_write_zeroes_fail(s, offset, ret);
 366             *error_is_read = false;
 367         }
 368         return ret;
 369     }
 370
 371     if (s->use_copy_range) {
 372         ret = bdrv_co_copy_range(s->source, offset, s->target, offset, nbytes,
 373                                  0, s->write_flags);
 374         if (ret < 0) {
 375             trace_block_copy_copy_range_fail(s, offset, ret);
 376             s->use_copy_range = false;
 377             s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
 378             /* Fallback to read+write with allocated buffer */
 379         } else {
 380             if (s->use_copy_range) {
 381                 /*
 382                  * Successful copy-range. Now increase copy_size.  copy_range
 383                  * does not respect max_transfer (it's a TODO), so we factor
 384                  * that in here.
 385                  *
 386                  * Note: we double-check s->use_copy_range for the case when
 387                  * parallel block-copy request unsets it during previous
 388                  * bdrv_co_copy_range call.
 389                  */
 390                 s->copy_size =
 391                         MIN(MAX(s->cluster_size, BLOCK_COPY_MAX_COPY_RANGE),
 392                             QEMU_ALIGN_DOWN(block_copy_max_transfer(s->source,
 393                                                                     s->target),
 394                                             s->cluster_size));
 395             }
 396             goto out;
 397         }
 398     }
 399
 400     /*
 401      * In case of failed copy_range request above, we may proceed with buffered
 402      * request larger than BLOCK_COPY_MAX_BUFFER. Still, further requests will
 403      * be properly limited, so don't care too much. Moreover the most likely
 404      * case (copy_range is unsupported for the configuration, so the very first
 405      * copy_range request fails) is handled by setting large copy_size only
 406      * after first successful copy_range.
 407      */
 408
 409     bounce_buffer = qemu_blockalign(s->source->bs, nbytes);
 410
 411     ret = bdrv_co_pread(s->source, offset, nbytes, bounce_buffer, 0);
 412     if (ret < 0) {
 413         trace_block_copy_read_fail(s, offset, ret);
 414         *error_is_read = true;
 415         goto out;
 416     }
 417
 418     ret = bdrv_co_pwrite(s->target, offset, nbytes, bounce_buffer,
 419                          s->write_flags);
 420     if (ret < 0) {
 421         trace_block_copy_write_fail(s, offset, ret);
 422         *error_is_read = false;
 423         goto out;
 424     }
 425
 426 out:
 427     qemu_vfree(bounce_buffer);
 428
 429     return ret;
 430 }
 431
 432 static coroutine_fn int block_copy_task_entry(AioTask *task)
 433 {
 434     BlockCopyTask *t = container_of(task, BlockCopyTask, task);
 435     bool error_is_read = false;
 436     int ret;
 437
 438     ret = block_copy_do_copy(t->s, t->offset, t->bytes, t->zeroes,
 439                              &error_is_read);
 440     if (ret < 0 && !t->call_state->ret) {
 441         t->call_state->ret = ret;
 442         t->call_state->error_is_read = error_is_read;
 443     } else {
 444         progress_work_done(t->s->progress, t->bytes);
 445     }
 446     co_put_to_shres(t->s->mem, t->bytes);
 447     block_copy_task_end(t, ret);
 448
 449     return ret;
 450 }
 451
 452 static int block_copy_block_status(BlockCopyState *s, int64_t offset,
 453                                    int64_t bytes, int64_t *pnum)
 454 {
 455     int64_t num;
 456     BlockDriverState *base;
 457     int ret;
 458
 459     if (s->skip_unallocated) {
 460         base = bdrv_backing_chain_next(s->source->bs);
 461     } else {
 462         base = NULL;
 463     }
 464
 465     ret = bdrv_block_status_above(s->source->bs, base, offset, bytes, &num,
 466                                   NULL, NULL);
 467     if (ret < 0 || num < s->cluster_size) {
 468         /*
 469          * On error or if failed to obtain large enough chunk just fallback to
 470          * copy one cluster.
 471          */
 472         num = s->cluster_size;
 473         ret = BDRV_BLOCK_ALLOCATED | BDRV_BLOCK_DATA;
 474     } else if (offset + num == s->len) {
 475         num = QEMU_ALIGN_UP(num, s->cluster_size);
 476     } else {
 477         num = QEMU_ALIGN_DOWN(num, s->cluster_size);
 478     }
 479
 480     *pnum = num;
 481     return ret;
 482 }
 483
 484 /*
 485  * Check if the cluster starting at offset is allocated or not.
 486  * return via pnum the number of contiguous clusters sharing this allocation.
 487  */
 488 static int block_copy_is_cluster_allocated(BlockCopyState *s, int64_t offset,
 489                                            int64_t *pnum)
 490 {
 491     BlockDriverState *bs = s->source->bs;
 492     int64_t count, total_count = 0;
 493     int64_t bytes = s->len - offset;
 494     int ret;
 495
 496     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
 497
 498     while (true) {
 499         ret = bdrv_is_allocated(bs, offset, bytes, &count);
 500         if (ret < 0) {
 501             return ret;
 502         }
 503
 504         total_count += count;
 505
 506         if (ret || count == 0) {
 507             /*
 508              * ret: partial segment(s) are considered allocated.
 509              * otherwise: unallocated tail is treated as an entire segment.
 510              */
 511             *pnum = DIV_ROUND_UP(total_count, s->cluster_size);
 512             return ret;
 513         }
 514
 515         /* Unallocated segment(s) with uncertain following segment(s) */
 516         if (total_count >= s->cluster_size) {
 517             *pnum = total_count / s->cluster_size;
 518             return 0;
 519         }
 520
 521         offset += count;
 522         bytes -= count;
 523     }
 524 }
 525
 526 /*
 527  * Reset bits in copy_bitmap starting at offset if they represent unallocated
 528  * data in the image. May reset subsequent contiguous bits.
 529  * @return 0 when the cluster at @offset was unallocated,
 530  *         1 otherwise, and -ret on error.
 531  */
 532 int64_t block_copy_reset_unallocated(BlockCopyState *s,
 533                                      int64_t offset, int64_t *count)
 534 {
 535     int ret;
 536     int64_t clusters, bytes;
 537
 538     ret = block_copy_is_cluster_allocated(s, offset, &clusters);
 539     if (ret < 0) {
 540         return ret;
 541     }
 542
 543     bytes = clusters * s->cluster_size;
 544
 545     if (!ret) {
 546         bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
 547         progress_set_remaining(s->progress,
 548                                bdrv_get_dirty_count(s->copy_bitmap) +
 549                                s->in_flight_bytes);
 550     }
 551
 552     *count = bytes;
 553     return ret;
 554 }
 555
 556 /*
 557  * block_copy_dirty_clusters
 558  *
 559  * Copy dirty clusters in @offset/@bytes range.
 560  * Returns 1 if dirty clusters found and successfully copied, 0 if no dirty
 561  * clusters found and -errno on failure.
 562  */
 563 static int coroutine_fn
 564 block_copy_dirty_clusters(BlockCopyCallState *call_state)
 565 {
 566     BlockCopyState *s = call_state->s;
 567     int64_t offset = call_state->offset;
 568     int64_t bytes = call_state->bytes;
 569
 570     int ret = 0;
 571     bool found_dirty = false;
 572     int64_t end = offset + bytes;
 573     AioTaskPool *aio = NULL;
 574
 575     /*
 576      * block_copy() user is responsible for keeping source and target in same
 577      * aio context
 578      */
 579     assert(bdrv_get_aio_context(s->source->bs) ==
 580            bdrv_get_aio_context(s->target->bs));
 581
 582     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
 583     assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 584
 585     while (bytes && aio_task_pool_status(aio) == 0 && !call_state->cancelled) {
 586         BlockCopyTask *task;
 587         int64_t status_bytes;
 588
 589         task = block_copy_task_create(s, call_state, offset, bytes);
 590         if (!task) {
 591             /* No more dirty bits in the bitmap */
 592             trace_block_copy_skip_range(s, offset, bytes);
 593             break;
 594         }
 595         if (task->offset > offset) {
 596             trace_block_copy_skip_range(s, offset, task->offset - offset);
 597         }
 598
 599         found_dirty = true;
 600
 601         ret = block_copy_block_status(s, task->offset, task->bytes,
 602                                       &status_bytes);
 603         assert(ret >= 0); /* never fail */
 604         if (status_bytes < task->bytes) {
 605             block_copy_task_shrink(task, status_bytes);
 606         }
 607         if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
 608             block_copy_task_end(task, 0);
 609             progress_set_remaining(s->progress,
 610                                    bdrv_get_dirty_count(s->copy_bitmap) +
 611                                    s->in_flight_bytes);
 612             trace_block_copy_skip_range(s, task->offset, task->bytes);
 613             offset = task_end(task);
 614             bytes = end - offset;
 615             g_free(task);
 616             continue;
 617         }
 618         task->zeroes = ret & BDRV_BLOCK_ZERO;
 619
 620         if (s->speed) {
 621             if (!call_state->ignore_ratelimit) {
 622                 uint64_t ns = ratelimit_calculate_delay(&s->rate_limit, 0);
 623                 if (ns > 0) {
 624                     block_copy_task_end(task, -EAGAIN);
 625                     g_free(task);
 626                     qemu_co_sleep_ns_wakeable(QEMU_CLOCK_REALTIME, ns,
 627                                               &call_state->sleep_state);
 628                     continue;
 629                 }
 630             }
 631
 632             ratelimit_calculate_delay(&s->rate_limit, task->bytes);
 633         }
 634
 635         trace_block_copy_process(s, task->offset);
 636
 637         co_get_from_shres(s->mem, task->bytes);
 638
 639         offset = task_end(task);
 640         bytes = end - offset;
 641
 642         if (!aio && bytes) {
 643             aio = aio_task_pool_new(call_state->max_workers);
 644         }
 645
 646         ret = block_copy_task_run(aio, task);
 647         if (ret < 0) {
 648             goto out;
 649         }
 650     }
 651
 652 out:
 653     if (aio) {
 654         aio_task_pool_wait_all(aio);
 655
 656         /*
 657          * We are not really interested in -ECANCELED returned from
 658          * block_copy_task_run. If it fails, it means some task already failed
 659          * for real reason, let's return first failure.
 660          * Still, assert that we don't rewrite failure by success.
 661          *
 662          * Note: ret may be positive here because of block-status result.
 663          */
 664         assert(ret >= 0 || aio_task_pool_status(aio) < 0);
 665         ret = aio_task_pool_status(aio);
 666
 667         aio_task_pool_free(aio);
 668     }
 669
 670     return ret < 0 ? ret : found_dirty;
 671 }
 672
 673 void block_copy_kick(BlockCopyCallState *call_state)
 674 {
 675     if (call_state->sleep_state) {
 676         qemu_co_sleep_wake(call_state->sleep_state);
 677     }
 678 }
 679
 680 /*
 681  * block_copy_common
 682  *
 683  * Copy requested region, accordingly to dirty bitmap.
 684  * Collaborate with parallel block_copy requests: if they succeed it will help
 685  * us. If they fail, we will retry not-copied regions. So, if we return error,
 686  * it means that some I/O operation failed in context of _this_ block_copy call,
 687  * not some parallel operation.
 688  */
 689 static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
 690 {
 691     int ret;
 692
 693     QLIST_INSERT_HEAD(&call_state->s->calls, call_state, list);
 694
 695     do {
 696         ret = block_copy_dirty_clusters(call_state);
 697
 698         if (ret == 0 && !call_state->cancelled) {
 699             ret = block_copy_wait_one(call_state->s, call_state->offset,
 700                                       call_state->bytes);
 701         }
 702
 703         /*
 704          * We retry in two cases:
 705          * 1. Some progress done
 706          *    Something was copied, which means that there were yield points
 707          *    and some new dirty bits may have appeared (due to failed parallel
 708          *    block-copy requests).
 709          * 2. We have waited for some intersecting block-copy request
 710          *    It may have failed and produced new dirty bits.
 711          */
 712     } while (ret > 0 && !call_state->cancelled);
 713
 714     call_state->finished = true;
 715
 716     if (call_state->cb) {
 717         call_state->cb(call_state->cb_opaque);
 718     }
 719
 720     QLIST_REMOVE(call_state, list);
 721
 722     return ret;
 723 }
 724
 725 int coroutine_fn block_copy(BlockCopyState *s, int64_t start, int64_t bytes,
 726                             bool ignore_ratelimit, bool *error_is_read)
 727 {
 728     BlockCopyCallState call_state = {
 729         .s = s,
 730         .offset = start,
 731         .bytes = bytes,
 732         .ignore_ratelimit = ignore_ratelimit,
 733         .max_workers = BLOCK_COPY_MAX_WORKERS,
 734     };
 735
 736     int ret = block_copy_common(&call_state);
 737
 738     if (error_is_read && ret < 0) {
 739         *error_is_read = call_state.error_is_read;
 740     }
 741
 742     return ret;
 743 }
 744
 745 static void coroutine_fn block_copy_async_co_entry(void *opaque)
 746 {
 747     block_copy_common(opaque);
 748 }
 749
 750 BlockCopyCallState *block_copy_async(BlockCopyState *s,
 751                                      int64_t offset, int64_t bytes,
 752                                      int max_workers, int64_t max_chunk,
 753                                      BlockCopyAsyncCallbackFunc cb,
 754                                      void *cb_opaque)
 755 {
 756     BlockCopyCallState *call_state = g_new(BlockCopyCallState, 1);
 757
 758     *call_state = (BlockCopyCallState) {
 759         .s = s,
 760         .offset = offset,
 761         .bytes = bytes,
 762         .max_workers = max_workers,
 763         .max_chunk = max_chunk,
 764         .cb = cb,
 765         .cb_opaque = cb_opaque,
 766
 767         .co = qemu_coroutine_create(block_copy_async_co_entry, call_state),
 768     };
 769
 770     qemu_coroutine_enter(call_state->co);
 771
 772     return call_state;
 773 }
 774
 775 void block_copy_call_free(BlockCopyCallState *call_state)
 776 {
 777     if (!call_state) {
 778         return;
 779     }
 780
 781     assert(call_state->finished);
 782     g_free(call_state);
 783 }
 784
 785 bool block_copy_call_finished(BlockCopyCallState *call_state)
 786 {
 787     return call_state->finished;
 788 }
 789
 790 bool block_copy_call_succeeded(BlockCopyCallState *call_state)
 791 {
 792     return call_state->finished && !call_state->cancelled &&
 793         call_state->ret == 0;
 794 }
 795
 796 bool block_copy_call_failed(BlockCopyCallState *call_state)
 797 {
 798     return call_state->finished && !call_state->cancelled &&
 799         call_state->ret < 0;
 800 }
 801
 802 bool block_copy_call_cancelled(BlockCopyCallState *call_state)
 803 {
 804     return call_state->cancelled;
 805 }
 806
 807 int block_copy_call_status(BlockCopyCallState *call_state, bool *error_is_read)
 808 {
 809     assert(call_state->finished);
 810     if (error_is_read) {
 811         *error_is_read = call_state->error_is_read;
 812     }
 813     return call_state->ret;
 814 }
 815
 816 void block_copy_call_cancel(BlockCopyCallState *call_state)
 817 {
 818     call_state->cancelled = true;
 819     block_copy_kick(call_state);
 820 }
 821
 822 BdrvDirtyBitmap *block_copy_dirty_bitmap(BlockCopyState *s)
 823 {
 824     return s->copy_bitmap;
 825 }
 826
 827 void block_copy_set_skip_unallocated(BlockCopyState *s, bool skip)
 828 {
 829     s->skip_unallocated = skip;
 830 }
 831
 832 void block_copy_set_speed(BlockCopyState *s, uint64_t speed)
 833 {
 834     s->speed = speed;
 835     if (speed > 0) {
 836         ratelimit_set_speed(&s->rate_limit, speed, BLOCK_COPY_SLICE_TIME);
 837     }
 838
 839     /*
 840      * Note: it's good to kick all call states from here, but it should be done
 841      * only from a coroutine, to not crash if s->calls list changed while
 842      * entering one call. So for now, the only user of this function kicks its
 843      * only one call_state by hand.
 844      */
 845 }