4 * Copyright (C) 2013 Proxmox Server Solutions
7 * Dietmar Maurer (dietmar@proxmox.com)
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
14 #include "qemu/osdep.h"
17 #include "block/block.h"
18 #include "block/block_int.h"
19 #include "block/blockjob.h"
20 #include "qapi/error.h"
21 #include "qapi/qmp/qerror.h"
22 #include "qemu/ratelimit.h"
23 #include "qemu/cutils.h"
24 #include "sysemu/block-backend.h"
25 #include "qemu/bitmap.h"
27 #define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
28 #define SLICE_TIME 100000000ULL /* ns */
30 typedef struct CowRequest
{
33 QLIST_ENTRY(CowRequest
) list
;
34 CoQueue wait_queue
; /* coroutines blocked on this request */
37 typedef struct BackupBlockJob
{
40 /* bitmap for sync=incremental */
41 BdrvDirtyBitmap
*sync_bitmap
;
42 MirrorSyncMode sync_mode
;
44 BlockdevOnError on_source_error
;
45 BlockdevOnError on_target_error
;
46 CoRwlock flush_rwlock
;
47 uint64_t sectors_read
;
48 unsigned long *done_bitmap
;
51 NotifierWithReturn before_write
;
52 QLIST_HEAD(, CowRequest
) inflight_reqs
;
55 /* Size of a cluster in sectors, instead of bytes. */
56 static inline int64_t cluster_size_sectors(BackupBlockJob
*job
)
58 return job
->cluster_size
/ BDRV_SECTOR_SIZE
;
61 /* See if in-flight requests overlap and wait for them to complete */
62 static void coroutine_fn
wait_for_overlapping_requests(BackupBlockJob
*job
,
71 QLIST_FOREACH(req
, &job
->inflight_reqs
, list
) {
72 if (end
> req
->start
&& start
< req
->end
) {
73 qemu_co_queue_wait(&req
->wait_queue
);
81 /* Keep track of an in-flight request */
82 static void cow_request_begin(CowRequest
*req
, BackupBlockJob
*job
,
83 int64_t start
, int64_t end
)
87 qemu_co_queue_init(&req
->wait_queue
);
88 QLIST_INSERT_HEAD(&job
->inflight_reqs
, req
, list
);
91 /* Forget about a completed request */
92 static void cow_request_end(CowRequest
*req
)
94 QLIST_REMOVE(req
, list
);
95 qemu_co_queue_restart_all(&req
->wait_queue
);
98 static int coroutine_fn
backup_do_cow(BackupBlockJob
*job
,
99 int64_t sector_num
, int nb_sectors
,
101 bool is_write_notifier
)
103 BlockBackend
*blk
= job
->common
.blk
;
104 CowRequest cow_request
;
106 QEMUIOVector bounce_qiov
;
107 void *bounce_buffer
= NULL
;
109 int64_t sectors_per_cluster
= cluster_size_sectors(job
);
113 qemu_co_rwlock_rdlock(&job
->flush_rwlock
);
115 start
= sector_num
/ sectors_per_cluster
;
116 end
= DIV_ROUND_UP(sector_num
+ nb_sectors
, sectors_per_cluster
);
118 trace_backup_do_cow_enter(job
, start
, sector_num
, nb_sectors
);
120 wait_for_overlapping_requests(job
, start
, end
);
121 cow_request_begin(&cow_request
, job
, start
, end
);
123 for (; start
< end
; start
++) {
124 if (test_bit(start
, job
->done_bitmap
)) {
125 trace_backup_do_cow_skip(job
, start
);
126 continue; /* already copied */
129 trace_backup_do_cow_process(job
, start
);
131 n
= MIN(sectors_per_cluster
,
132 job
->common
.len
/ BDRV_SECTOR_SIZE
-
133 start
* sectors_per_cluster
);
135 if (!bounce_buffer
) {
136 bounce_buffer
= blk_blockalign(blk
, job
->cluster_size
);
138 iov
.iov_base
= bounce_buffer
;
139 iov
.iov_len
= n
* BDRV_SECTOR_SIZE
;
140 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
142 ret
= blk_co_preadv(blk
, start
* job
->cluster_size
,
143 bounce_qiov
.size
, &bounce_qiov
,
144 is_write_notifier
? BDRV_REQ_NO_SERIALISING
: 0);
146 trace_backup_do_cow_read_fail(job
, start
, ret
);
148 *error_is_read
= true;
153 if (buffer_is_zero(iov
.iov_base
, iov
.iov_len
)) {
154 ret
= blk_co_pwrite_zeroes(job
->target
, start
* job
->cluster_size
,
155 bounce_qiov
.size
, BDRV_REQ_MAY_UNMAP
);
157 ret
= blk_co_pwritev(job
->target
, start
* job
->cluster_size
,
158 bounce_qiov
.size
, &bounce_qiov
,
159 job
->compress
? BDRV_REQ_WRITE_COMPRESSED
: 0);
162 trace_backup_do_cow_write_fail(job
, start
, ret
);
164 *error_is_read
= false;
169 set_bit(start
, job
->done_bitmap
);
171 /* Publish progress, guest I/O counts as progress too. Note that the
172 * offset field is an opaque progress value, it is not a disk offset.
174 job
->sectors_read
+= n
;
175 job
->common
.offset
+= n
* BDRV_SECTOR_SIZE
;
180 qemu_vfree(bounce_buffer
);
183 cow_request_end(&cow_request
);
185 trace_backup_do_cow_return(job
, sector_num
, nb_sectors
, ret
);
187 qemu_co_rwlock_unlock(&job
->flush_rwlock
);
192 static int coroutine_fn
backup_before_write_notify(
193 NotifierWithReturn
*notifier
,
196 BackupBlockJob
*job
= container_of(notifier
, BackupBlockJob
, before_write
);
197 BdrvTrackedRequest
*req
= opaque
;
198 int64_t sector_num
= req
->offset
>> BDRV_SECTOR_BITS
;
199 int nb_sectors
= req
->bytes
>> BDRV_SECTOR_BITS
;
201 assert(req
->bs
== blk_bs(job
->common
.blk
));
202 assert((req
->offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
203 assert((req
->bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
205 return backup_do_cow(job
, sector_num
, nb_sectors
, NULL
, true);
208 static void backup_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
210 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
213 error_setg(errp
, QERR_INVALID_PARAMETER
, "speed");
216 ratelimit_set_speed(&s
->limit
, speed
/ BDRV_SECTOR_SIZE
, SLICE_TIME
);
219 static void backup_cleanup_sync_bitmap(BackupBlockJob
*job
, int ret
)
222 BlockDriverState
*bs
= blk_bs(job
->common
.blk
);
224 if (ret
< 0 || block_job_is_cancelled(&job
->common
)) {
225 /* Merge the successor back into the parent, delete nothing. */
226 bm
= bdrv_reclaim_dirty_bitmap(bs
, job
->sync_bitmap
, NULL
);
229 /* Everything is fine, delete this bitmap and install the backup. */
230 bm
= bdrv_dirty_bitmap_abdicate(bs
, job
->sync_bitmap
, NULL
);
235 static void backup_commit(BlockJob
*job
)
237 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
238 if (s
->sync_bitmap
) {
239 backup_cleanup_sync_bitmap(s
, 0);
243 static void backup_abort(BlockJob
*job
)
245 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
246 if (s
->sync_bitmap
) {
247 backup_cleanup_sync_bitmap(s
, -1);
251 static void backup_attached_aio_context(BlockJob
*job
, AioContext
*aio_context
)
253 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
255 blk_set_aio_context(s
->target
, aio_context
);
258 static const BlockJobDriver backup_job_driver
= {
259 .instance_size
= sizeof(BackupBlockJob
),
260 .job_type
= BLOCK_JOB_TYPE_BACKUP
,
261 .set_speed
= backup_set_speed
,
262 .commit
= backup_commit
,
263 .abort
= backup_abort
,
264 .attached_aio_context
= backup_attached_aio_context
,
267 static BlockErrorAction
backup_error_action(BackupBlockJob
*job
,
268 bool read
, int error
)
271 return block_job_error_action(&job
->common
, job
->on_source_error
,
274 return block_job_error_action(&job
->common
, job
->on_target_error
,
281 } BackupCompleteData
;
283 static void backup_complete(BlockJob
*job
, void *opaque
)
285 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
286 BackupCompleteData
*data
= opaque
;
288 blk_unref(s
->target
);
290 block_job_completed(job
, data
->ret
);
294 static bool coroutine_fn
yield_and_check(BackupBlockJob
*job
)
296 if (block_job_is_cancelled(&job
->common
)) {
300 /* we need to yield so that bdrv_drain_all() returns.
301 * (without, VM does not reboot)
303 if (job
->common
.speed
) {
304 uint64_t delay_ns
= ratelimit_calculate_delay(&job
->limit
,
306 job
->sectors_read
= 0;
307 block_job_sleep_ns(&job
->common
, QEMU_CLOCK_REALTIME
, delay_ns
);
309 block_job_sleep_ns(&job
->common
, QEMU_CLOCK_REALTIME
, 0);
312 if (block_job_is_cancelled(&job
->common
)) {
319 static int coroutine_fn
backup_run_incremental(BackupBlockJob
*job
)
323 int clusters_per_iter
;
324 uint32_t granularity
;
328 int64_t last_cluster
= -1;
329 int64_t sectors_per_cluster
= cluster_size_sectors(job
);
332 granularity
= bdrv_dirty_bitmap_granularity(job
->sync_bitmap
);
333 clusters_per_iter
= MAX((granularity
/ job
->cluster_size
), 1);
334 bdrv_dirty_iter_init(job
->sync_bitmap
, &hbi
);
336 /* Find the next dirty sector(s) */
337 while ((sector
= hbitmap_iter_next(&hbi
)) != -1) {
338 cluster
= sector
/ sectors_per_cluster
;
340 /* Fake progress updates for any clusters we skipped */
341 if (cluster
!= last_cluster
+ 1) {
342 job
->common
.offset
+= ((cluster
- last_cluster
- 1) *
346 for (end
= cluster
+ clusters_per_iter
; cluster
< end
; cluster
++) {
348 if (yield_and_check(job
)) {
351 ret
= backup_do_cow(job
, cluster
* sectors_per_cluster
,
352 sectors_per_cluster
, &error_is_read
,
355 backup_error_action(job
, error_is_read
, -ret
) ==
356 BLOCK_ERROR_ACTION_REPORT
) {
362 /* If the bitmap granularity is smaller than the backup granularity,
363 * we need to advance the iterator pointer to the next cluster. */
364 if (granularity
< job
->cluster_size
) {
365 bdrv_set_dirty_iter(&hbi
, cluster
* sectors_per_cluster
);
368 last_cluster
= cluster
- 1;
371 /* Play some final catchup with the progress meter */
372 end
= DIV_ROUND_UP(job
->common
.len
, job
->cluster_size
);
373 if (last_cluster
+ 1 < end
) {
374 job
->common
.offset
+= ((end
- last_cluster
- 1) * job
->cluster_size
);
380 static void coroutine_fn
backup_run(void *opaque
)
382 BackupBlockJob
*job
= opaque
;
383 BackupCompleteData
*data
;
384 BlockDriverState
*bs
= blk_bs(job
->common
.blk
);
385 BlockBackend
*target
= job
->target
;
387 int64_t sectors_per_cluster
= cluster_size_sectors(job
);
390 QLIST_INIT(&job
->inflight_reqs
);
391 qemu_co_rwlock_init(&job
->flush_rwlock
);
394 end
= DIV_ROUND_UP(job
->common
.len
, job
->cluster_size
);
396 job
->done_bitmap
= bitmap_new(end
);
398 job
->before_write
.notify
= backup_before_write_notify
;
399 bdrv_add_before_write_notifier(bs
, &job
->before_write
);
401 if (job
->sync_mode
== MIRROR_SYNC_MODE_NONE
) {
402 while (!block_job_is_cancelled(&job
->common
)) {
403 /* Yield until the job is cancelled. We just let our before_write
404 * notify callback service CoW requests. */
405 block_job_yield(&job
->common
);
407 } else if (job
->sync_mode
== MIRROR_SYNC_MODE_INCREMENTAL
) {
408 ret
= backup_run_incremental(job
);
410 /* Both FULL and TOP SYNC_MODE's require copying.. */
411 for (; start
< end
; start
++) {
413 if (yield_and_check(job
)) {
417 if (job
->sync_mode
== MIRROR_SYNC_MODE_TOP
) {
421 /* Check to see if these blocks are already in the
424 for (i
= 0; i
< sectors_per_cluster
;) {
425 /* bdrv_is_allocated() only returns true/false based
426 * on the first set of sectors it comes across that
427 * are are all in the same state.
428 * For that reason we must verify each sector in the
429 * backup cluster length. We end up copying more than
430 * needed but at some point that is always the case. */
432 bdrv_is_allocated(bs
,
433 start
* sectors_per_cluster
+ i
,
434 sectors_per_cluster
- i
, &n
);
437 if (alloced
== 1 || n
== 0) {
442 /* If the above loop never found any sectors that are in
443 * the topmost image, skip this backup. */
448 /* FULL sync mode we copy the whole drive. */
449 ret
= backup_do_cow(job
, start
* sectors_per_cluster
,
450 sectors_per_cluster
, &error_is_read
, false);
452 /* Depending on error action, fail now or retry cluster */
453 BlockErrorAction action
=
454 backup_error_action(job
, error_is_read
, -ret
);
455 if (action
== BLOCK_ERROR_ACTION_REPORT
) {
465 notifier_with_return_remove(&job
->before_write
);
467 /* wait until pending backup_do_cow() calls have completed */
468 qemu_co_rwlock_wrlock(&job
->flush_rwlock
);
469 qemu_co_rwlock_unlock(&job
->flush_rwlock
);
470 g_free(job
->done_bitmap
);
472 bdrv_op_unblock_all(blk_bs(target
), job
->common
.blocker
);
474 data
= g_malloc(sizeof(*data
));
476 block_job_defer_to_main_loop(&job
->common
, backup_complete
, data
);
479 void backup_start(const char *job_id
, BlockDriverState
*bs
,
480 BlockDriverState
*target
, int64_t speed
,
481 MirrorSyncMode sync_mode
, BdrvDirtyBitmap
*sync_bitmap
,
483 BlockdevOnError on_source_error
,
484 BlockdevOnError on_target_error
,
485 BlockCompletionFunc
*cb
, void *opaque
,
486 BlockJobTxn
*txn
, Error
**errp
)
490 BackupBlockJob
*job
= NULL
;
497 error_setg(errp
, "Source and target cannot be the same");
501 if (!bdrv_is_inserted(bs
)) {
502 error_setg(errp
, "Device is not inserted: %s",
503 bdrv_get_device_name(bs
));
507 if (!bdrv_is_inserted(target
)) {
508 error_setg(errp
, "Device is not inserted: %s",
509 bdrv_get_device_name(target
));
513 if (compress
&& target
->drv
->bdrv_co_pwritev_compressed
== NULL
) {
514 error_setg(errp
, "Compression is not supported for this drive %s",
515 bdrv_get_device_name(target
));
519 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_BACKUP_SOURCE
, errp
)) {
523 if (bdrv_op_is_blocked(target
, BLOCK_OP_TYPE_BACKUP_TARGET
, errp
)) {
527 if (sync_mode
== MIRROR_SYNC_MODE_INCREMENTAL
) {
529 error_setg(errp
, "must provide a valid bitmap name for "
530 "\"incremental\" sync mode");
534 /* Create a new bitmap, and freeze/disable this one. */
535 if (bdrv_dirty_bitmap_create_successor(bs
, sync_bitmap
, errp
) < 0) {
538 } else if (sync_bitmap
) {
540 "a sync_bitmap was provided to backup_run, "
541 "but received an incompatible sync_mode (%s)",
542 MirrorSyncMode_lookup
[sync_mode
]);
546 len
= bdrv_getlength(bs
);
548 error_setg_errno(errp
, -len
, "unable to get length for '%s'",
549 bdrv_get_device_name(bs
));
553 job
= block_job_create(job_id
, &backup_job_driver
, bs
, speed
,
559 job
->target
= blk_new();
560 blk_insert_bs(job
->target
, target
);
562 job
->on_source_error
= on_source_error
;
563 job
->on_target_error
= on_target_error
;
564 job
->sync_mode
= sync_mode
;
565 job
->sync_bitmap
= sync_mode
== MIRROR_SYNC_MODE_INCREMENTAL
?
567 job
->compress
= compress
;
569 /* If there is no backing file on the target, we cannot rely on COW if our
570 * backup cluster size is smaller than the target cluster size. Even for
571 * targets with a backing file, try to avoid COW if possible. */
572 ret
= bdrv_get_info(target
, &bdi
);
573 if (ret
< 0 && !target
->backing
) {
574 error_setg_errno(errp
, -ret
,
575 "Couldn't determine the cluster size of the target image, "
576 "which has no backing file");
577 error_append_hint(errp
,
578 "Aborting, since this may create an unusable destination image\n");
580 } else if (ret
< 0 && target
->backing
) {
581 /* Not fatal; just trudge on ahead. */
582 job
->cluster_size
= BACKUP_CLUSTER_SIZE_DEFAULT
;
584 job
->cluster_size
= MAX(BACKUP_CLUSTER_SIZE_DEFAULT
, bdi
.cluster_size
);
587 bdrv_op_block_all(target
, job
->common
.blocker
);
588 job
->common
.len
= len
;
589 job
->common
.co
= qemu_coroutine_create(backup_run
, job
);
590 block_job_txn_add_job(txn
, &job
->common
);
591 qemu_coroutine_enter(job
->common
.co
);
596 bdrv_reclaim_dirty_bitmap(bs
, sync_bitmap
, NULL
);
599 blk_unref(job
->target
);
600 block_job_unref(&job
->common
);