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 "sysemu/block-backend.h"
24 #include "qemu/bitmap.h"
26 #define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
27 #define SLICE_TIME 100000000ULL /* ns */
29 typedef struct CowRequest
{
32 QLIST_ENTRY(CowRequest
) list
;
33 CoQueue wait_queue
; /* coroutines blocked on this request */
36 typedef struct BackupBlockJob
{
38 BlockDriverState
*target
;
39 /* bitmap for sync=incremental */
40 BdrvDirtyBitmap
*sync_bitmap
;
41 MirrorSyncMode sync_mode
;
43 BlockdevOnError on_source_error
;
44 BlockdevOnError on_target_error
;
45 CoRwlock flush_rwlock
;
46 uint64_t sectors_read
;
47 unsigned long *done_bitmap
;
49 QLIST_HEAD(, CowRequest
) inflight_reqs
;
52 /* Size of a cluster in sectors, instead of bytes. */
53 static inline int64_t cluster_size_sectors(BackupBlockJob
*job
)
55 return job
->cluster_size
/ BDRV_SECTOR_SIZE
;
58 /* See if in-flight requests overlap and wait for them to complete */
59 static void coroutine_fn
wait_for_overlapping_requests(BackupBlockJob
*job
,
68 QLIST_FOREACH(req
, &job
->inflight_reqs
, list
) {
69 if (end
> req
->start
&& start
< req
->end
) {
70 qemu_co_queue_wait(&req
->wait_queue
);
78 /* Keep track of an in-flight request */
79 static void cow_request_begin(CowRequest
*req
, BackupBlockJob
*job
,
80 int64_t start
, int64_t end
)
84 qemu_co_queue_init(&req
->wait_queue
);
85 QLIST_INSERT_HEAD(&job
->inflight_reqs
, req
, list
);
88 /* Forget about a completed request */
89 static void cow_request_end(CowRequest
*req
)
91 QLIST_REMOVE(req
, list
);
92 qemu_co_queue_restart_all(&req
->wait_queue
);
95 static int coroutine_fn
backup_do_cow(BlockDriverState
*bs
,
96 int64_t sector_num
, int nb_sectors
,
98 bool is_write_notifier
)
100 BackupBlockJob
*job
= (BackupBlockJob
*)bs
->job
;
101 CowRequest cow_request
;
103 QEMUIOVector bounce_qiov
;
104 void *bounce_buffer
= NULL
;
106 int64_t sectors_per_cluster
= cluster_size_sectors(job
);
110 qemu_co_rwlock_rdlock(&job
->flush_rwlock
);
112 start
= sector_num
/ sectors_per_cluster
;
113 end
= DIV_ROUND_UP(sector_num
+ nb_sectors
, sectors_per_cluster
);
115 trace_backup_do_cow_enter(job
, start
, sector_num
, nb_sectors
);
117 wait_for_overlapping_requests(job
, start
, end
);
118 cow_request_begin(&cow_request
, job
, start
, end
);
120 for (; start
< end
; start
++) {
121 if (test_bit(start
, job
->done_bitmap
)) {
122 trace_backup_do_cow_skip(job
, start
);
123 continue; /* already copied */
126 trace_backup_do_cow_process(job
, start
);
128 n
= MIN(sectors_per_cluster
,
129 job
->common
.len
/ BDRV_SECTOR_SIZE
-
130 start
* sectors_per_cluster
);
132 if (!bounce_buffer
) {
133 bounce_buffer
= qemu_blockalign(bs
, job
->cluster_size
);
135 iov
.iov_base
= bounce_buffer
;
136 iov
.iov_len
= n
* BDRV_SECTOR_SIZE
;
137 qemu_iovec_init_external(&bounce_qiov
, &iov
, 1);
139 if (is_write_notifier
) {
140 ret
= bdrv_co_readv_no_serialising(bs
,
141 start
* sectors_per_cluster
,
144 ret
= bdrv_co_readv(bs
, start
* sectors_per_cluster
, n
,
148 trace_backup_do_cow_read_fail(job
, start
, ret
);
150 *error_is_read
= true;
155 if (buffer_is_zero(iov
.iov_base
, iov
.iov_len
)) {
156 ret
= bdrv_co_write_zeroes(job
->target
,
157 start
* sectors_per_cluster
,
158 n
, BDRV_REQ_MAY_UNMAP
);
160 ret
= bdrv_co_writev(job
->target
,
161 start
* sectors_per_cluster
, n
,
165 trace_backup_do_cow_write_fail(job
, start
, ret
);
167 *error_is_read
= false;
172 set_bit(start
, job
->done_bitmap
);
174 /* Publish progress, guest I/O counts as progress too. Note that the
175 * offset field is an opaque progress value, it is not a disk offset.
177 job
->sectors_read
+= n
;
178 job
->common
.offset
+= n
* BDRV_SECTOR_SIZE
;
183 qemu_vfree(bounce_buffer
);
186 cow_request_end(&cow_request
);
188 trace_backup_do_cow_return(job
, sector_num
, nb_sectors
, ret
);
190 qemu_co_rwlock_unlock(&job
->flush_rwlock
);
195 static int coroutine_fn
backup_before_write_notify(
196 NotifierWithReturn
*notifier
,
199 BdrvTrackedRequest
*req
= opaque
;
200 int64_t sector_num
= req
->offset
>> BDRV_SECTOR_BITS
;
201 int nb_sectors
= req
->bytes
>> BDRV_SECTOR_BITS
;
203 assert((req
->offset
& (BDRV_SECTOR_SIZE
- 1)) == 0);
204 assert((req
->bytes
& (BDRV_SECTOR_SIZE
- 1)) == 0);
206 return backup_do_cow(req
->bs
, sector_num
, nb_sectors
, NULL
, true);
209 static void backup_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
211 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
214 error_setg(errp
, QERR_INVALID_PARAMETER
, "speed");
217 ratelimit_set_speed(&s
->limit
, speed
/ BDRV_SECTOR_SIZE
, SLICE_TIME
);
220 static void backup_iostatus_reset(BlockJob
*job
)
222 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
224 if (s
->target
->blk
) {
225 blk_iostatus_reset(s
->target
->blk
);
229 static void backup_cleanup_sync_bitmap(BackupBlockJob
*job
, int ret
)
232 BlockDriverState
*bs
= job
->common
.bs
;
234 if (ret
< 0 || block_job_is_cancelled(&job
->common
)) {
235 /* Merge the successor back into the parent, delete nothing. */
236 bm
= bdrv_reclaim_dirty_bitmap(bs
, job
->sync_bitmap
, NULL
);
239 /* Everything is fine, delete this bitmap and install the backup. */
240 bm
= bdrv_dirty_bitmap_abdicate(bs
, job
->sync_bitmap
, NULL
);
245 static void backup_commit(BlockJob
*job
)
247 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
248 if (s
->sync_bitmap
) {
249 backup_cleanup_sync_bitmap(s
, 0);
253 static void backup_abort(BlockJob
*job
)
255 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
256 if (s
->sync_bitmap
) {
257 backup_cleanup_sync_bitmap(s
, -1);
261 static const BlockJobDriver backup_job_driver
= {
262 .instance_size
= sizeof(BackupBlockJob
),
263 .job_type
= BLOCK_JOB_TYPE_BACKUP
,
264 .set_speed
= backup_set_speed
,
265 .iostatus_reset
= backup_iostatus_reset
,
266 .commit
= backup_commit
,
267 .abort
= backup_abort
,
270 static BlockErrorAction
backup_error_action(BackupBlockJob
*job
,
271 bool read
, int error
)
274 return block_job_error_action(&job
->common
, job
->common
.bs
,
275 job
->on_source_error
, true, error
);
277 return block_job_error_action(&job
->common
, job
->target
,
278 job
->on_target_error
, false, error
);
284 } BackupCompleteData
;
286 static void backup_complete(BlockJob
*job
, void *opaque
)
288 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
);
289 BackupCompleteData
*data
= opaque
;
291 bdrv_unref(s
->target
);
293 block_job_completed(job
, data
->ret
);
297 static bool coroutine_fn
yield_and_check(BackupBlockJob
*job
)
299 if (block_job_is_cancelled(&job
->common
)) {
303 /* we need to yield so that bdrv_drain_all() returns.
304 * (without, VM does not reboot)
306 if (job
->common
.speed
) {
307 uint64_t delay_ns
= ratelimit_calculate_delay(&job
->limit
,
309 job
->sectors_read
= 0;
310 block_job_sleep_ns(&job
->common
, QEMU_CLOCK_REALTIME
, delay_ns
);
312 block_job_sleep_ns(&job
->common
, QEMU_CLOCK_REALTIME
, 0);
315 if (block_job_is_cancelled(&job
->common
)) {
322 static int coroutine_fn
backup_run_incremental(BackupBlockJob
*job
)
326 int clusters_per_iter
;
327 uint32_t granularity
;
331 int64_t last_cluster
= -1;
332 int64_t sectors_per_cluster
= cluster_size_sectors(job
);
333 BlockDriverState
*bs
= job
->common
.bs
;
336 granularity
= bdrv_dirty_bitmap_granularity(job
->sync_bitmap
);
337 clusters_per_iter
= MAX((granularity
/ job
->cluster_size
), 1);
338 bdrv_dirty_iter_init(job
->sync_bitmap
, &hbi
);
340 /* Find the next dirty sector(s) */
341 while ((sector
= hbitmap_iter_next(&hbi
)) != -1) {
342 cluster
= sector
/ sectors_per_cluster
;
344 /* Fake progress updates for any clusters we skipped */
345 if (cluster
!= last_cluster
+ 1) {
346 job
->common
.offset
+= ((cluster
- last_cluster
- 1) *
350 for (end
= cluster
+ clusters_per_iter
; cluster
< end
; cluster
++) {
352 if (yield_and_check(job
)) {
355 ret
= backup_do_cow(bs
, cluster
* sectors_per_cluster
,
356 sectors_per_cluster
, &error_is_read
,
359 backup_error_action(job
, error_is_read
, -ret
) ==
360 BLOCK_ERROR_ACTION_REPORT
) {
366 /* If the bitmap granularity is smaller than the backup granularity,
367 * we need to advance the iterator pointer to the next cluster. */
368 if (granularity
< job
->cluster_size
) {
369 bdrv_set_dirty_iter(&hbi
, cluster
* sectors_per_cluster
);
372 last_cluster
= cluster
- 1;
375 /* Play some final catchup with the progress meter */
376 end
= DIV_ROUND_UP(job
->common
.len
, job
->cluster_size
);
377 if (last_cluster
+ 1 < end
) {
378 job
->common
.offset
+= ((end
- last_cluster
- 1) * job
->cluster_size
);
384 static void coroutine_fn
backup_run(void *opaque
)
386 BackupBlockJob
*job
= opaque
;
387 BackupCompleteData
*data
;
388 BlockDriverState
*bs
= job
->common
.bs
;
389 BlockDriverState
*target
= job
->target
;
390 BlockdevOnError on_target_error
= job
->on_target_error
;
391 NotifierWithReturn before_write
= {
392 .notify
= backup_before_write_notify
,
395 int64_t sectors_per_cluster
= cluster_size_sectors(job
);
398 QLIST_INIT(&job
->inflight_reqs
);
399 qemu_co_rwlock_init(&job
->flush_rwlock
);
402 end
= DIV_ROUND_UP(job
->common
.len
, job
->cluster_size
);
404 job
->done_bitmap
= bitmap_new(end
);
406 bdrv_set_enable_write_cache(target
, true);
408 blk_set_on_error(target
->blk
, on_target_error
, on_target_error
);
409 blk_iostatus_enable(target
->blk
);
412 bdrv_add_before_write_notifier(bs
, &before_write
);
414 if (job
->sync_mode
== MIRROR_SYNC_MODE_NONE
) {
415 while (!block_job_is_cancelled(&job
->common
)) {
416 /* Yield until the job is cancelled. We just let our before_write
417 * notify callback service CoW requests. */
418 job
->common
.busy
= false;
419 qemu_coroutine_yield();
420 job
->common
.busy
= true;
422 } else if (job
->sync_mode
== MIRROR_SYNC_MODE_INCREMENTAL
) {
423 ret
= backup_run_incremental(job
);
425 /* Both FULL and TOP SYNC_MODE's require copying.. */
426 for (; start
< end
; start
++) {
428 if (yield_and_check(job
)) {
432 if (job
->sync_mode
== MIRROR_SYNC_MODE_TOP
) {
436 /* Check to see if these blocks are already in the
439 for (i
= 0; i
< sectors_per_cluster
;) {
440 /* bdrv_is_allocated() only returns true/false based
441 * on the first set of sectors it comes across that
442 * are are all in the same state.
443 * For that reason we must verify each sector in the
444 * backup cluster length. We end up copying more than
445 * needed but at some point that is always the case. */
447 bdrv_is_allocated(bs
,
448 start
* sectors_per_cluster
+ i
,
449 sectors_per_cluster
- i
, &n
);
452 if (alloced
== 1 || n
== 0) {
457 /* If the above loop never found any sectors that are in
458 * the topmost image, skip this backup. */
463 /* FULL sync mode we copy the whole drive. */
464 ret
= backup_do_cow(bs
, start
* sectors_per_cluster
,
465 sectors_per_cluster
, &error_is_read
, false);
467 /* Depending on error action, fail now or retry cluster */
468 BlockErrorAction action
=
469 backup_error_action(job
, error_is_read
, -ret
);
470 if (action
== BLOCK_ERROR_ACTION_REPORT
) {
480 notifier_with_return_remove(&before_write
);
482 /* wait until pending backup_do_cow() calls have completed */
483 qemu_co_rwlock_wrlock(&job
->flush_rwlock
);
484 qemu_co_rwlock_unlock(&job
->flush_rwlock
);
485 g_free(job
->done_bitmap
);
488 blk_iostatus_disable(target
->blk
);
490 bdrv_op_unblock_all(target
, job
->common
.blocker
);
492 data
= g_malloc(sizeof(*data
));
494 block_job_defer_to_main_loop(&job
->common
, backup_complete
, data
);
497 void backup_start(BlockDriverState
*bs
, BlockDriverState
*target
,
498 int64_t speed
, MirrorSyncMode sync_mode
,
499 BdrvDirtyBitmap
*sync_bitmap
,
500 BlockdevOnError on_source_error
,
501 BlockdevOnError on_target_error
,
502 BlockCompletionFunc
*cb
, void *opaque
,
503 BlockJobTxn
*txn
, Error
**errp
)
514 error_setg(errp
, "Source and target cannot be the same");
518 if ((on_source_error
== BLOCKDEV_ON_ERROR_STOP
||
519 on_source_error
== BLOCKDEV_ON_ERROR_ENOSPC
) &&
520 (!bs
->blk
|| !blk_iostatus_is_enabled(bs
->blk
))) {
521 error_setg(errp
, QERR_INVALID_PARAMETER
, "on-source-error");
525 if (!bdrv_is_inserted(bs
)) {
526 error_setg(errp
, "Device is not inserted: %s",
527 bdrv_get_device_name(bs
));
531 if (!bdrv_is_inserted(target
)) {
532 error_setg(errp
, "Device is not inserted: %s",
533 bdrv_get_device_name(target
));
537 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_BACKUP_SOURCE
, errp
)) {
541 if (bdrv_op_is_blocked(target
, BLOCK_OP_TYPE_BACKUP_TARGET
, errp
)) {
545 if (sync_mode
== MIRROR_SYNC_MODE_INCREMENTAL
) {
547 error_setg(errp
, "must provide a valid bitmap name for "
548 "\"incremental\" sync mode");
552 /* Create a new bitmap, and freeze/disable this one. */
553 if (bdrv_dirty_bitmap_create_successor(bs
, sync_bitmap
, errp
) < 0) {
556 } else if (sync_bitmap
) {
558 "a sync_bitmap was provided to backup_run, "
559 "but received an incompatible sync_mode (%s)",
560 MirrorSyncMode_lookup
[sync_mode
]);
564 len
= bdrv_getlength(bs
);
566 error_setg_errno(errp
, -len
, "unable to get length for '%s'",
567 bdrv_get_device_name(bs
));
571 BackupBlockJob
*job
= block_job_create(&backup_job_driver
, bs
, speed
,
577 job
->on_source_error
= on_source_error
;
578 job
->on_target_error
= on_target_error
;
579 job
->target
= target
;
580 job
->sync_mode
= sync_mode
;
581 job
->sync_bitmap
= sync_mode
== MIRROR_SYNC_MODE_INCREMENTAL
?
584 /* If there is no backing file on the target, we cannot rely on COW if our
585 * backup cluster size is smaller than the target cluster size. Even for
586 * targets with a backing file, try to avoid COW if possible. */
587 ret
= bdrv_get_info(job
->target
, &bdi
);
588 if (ret
< 0 && !target
->backing
) {
589 error_setg_errno(errp
, -ret
,
590 "Couldn't determine the cluster size of the target image, "
591 "which has no backing file");
592 error_append_hint(errp
,
593 "Aborting, since this may create an unusable destination image\n");
595 } else if (ret
< 0 && target
->backing
) {
596 /* Not fatal; just trudge on ahead. */
597 job
->cluster_size
= BACKUP_CLUSTER_SIZE_DEFAULT
;
599 job
->cluster_size
= MAX(BACKUP_CLUSTER_SIZE_DEFAULT
, bdi
.cluster_size
);
602 bdrv_op_block_all(target
, job
->common
.blocker
);
603 job
->common
.len
= len
;
604 job
->common
.co
= qemu_coroutine_create(backup_run
);
605 block_job_txn_add_job(txn
, &job
->common
);
606 qemu_coroutine_enter(job
->common
.co
, job
);
611 bdrv_reclaim_dirty_bitmap(bs
, sync_bitmap
, NULL
);