4 * Copyright (C) 2013 Proxmox Server Solutions
5 * Copyright (c) 2019 Virtuozzo International GmbH.
8 * Dietmar Maurer (dietmar@proxmox.com)
10 * This work is licensed under the terms of the GNU GPL, version 2 or later.
11 * See the COPYING file in the top-level directory.
15 #include "qemu/osdep.h"
18 #include "block/block.h"
19 #include "block/block_int.h"
20 #include "block/blockjob_int.h"
21 #include "block/block_backup.h"
22 #include "block/block-copy.h"
23 #include "qapi/error.h"
24 #include "qapi/qmp/qerror.h"
25 #include "qemu/ratelimit.h"
26 #include "qemu/cutils.h"
27 #include "sysemu/block-backend.h"
28 #include "qemu/bitmap.h"
29 #include "qemu/error-report.h"
31 #include "block/backup-top.h"
33 #define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
35 typedef struct BackupBlockJob
{
37 BlockDriverState
*backup_top
;
38 BlockDriverState
*source_bs
;
40 BdrvDirtyBitmap
*sync_bitmap
;
42 MirrorSyncMode sync_mode
;
43 BitmapSyncMode bitmap_mode
;
44 BlockdevOnError on_source_error
;
45 BlockdevOnError on_target_error
;
54 static const BlockJobDriver backup_job_driver
;
56 static void backup_progress_bytes_callback(int64_t bytes
, void *opaque
)
58 BackupBlockJob
*s
= opaque
;
60 s
->bytes_read
+= bytes
;
63 static int coroutine_fn
backup_do_cow(BackupBlockJob
*job
,
64 int64_t offset
, uint64_t bytes
,
68 int64_t start
, end
; /* bytes */
70 start
= QEMU_ALIGN_DOWN(offset
, job
->cluster_size
);
71 end
= QEMU_ALIGN_UP(bytes
+ offset
, job
->cluster_size
);
73 trace_backup_do_cow_enter(job
, start
, offset
, bytes
);
75 ret
= block_copy(job
->bcs
, start
, end
- start
, error_is_read
);
77 trace_backup_do_cow_return(job
, offset
, bytes
, ret
);
82 static void backup_cleanup_sync_bitmap(BackupBlockJob
*job
, int ret
)
85 bool sync
= (((ret
== 0) || (job
->bitmap_mode
== BITMAP_SYNC_MODE_ALWAYS
)) \
86 && (job
->bitmap_mode
!= BITMAP_SYNC_MODE_NEVER
));
90 * We succeeded, or we always intended to sync the bitmap.
91 * Delete this bitmap and install the child.
93 bm
= bdrv_dirty_bitmap_abdicate(job
->sync_bitmap
, NULL
);
96 * We failed, or we never intended to sync the bitmap anyway.
97 * Merge the successor back into the parent, keeping all data.
99 bm
= bdrv_reclaim_dirty_bitmap(job
->sync_bitmap
, NULL
);
104 if (ret
< 0 && job
->bitmap_mode
== BITMAP_SYNC_MODE_ALWAYS
) {
105 /* If we failed and synced, merge in the bits we didn't copy: */
106 bdrv_dirty_bitmap_merge_internal(bm
, block_copy_dirty_bitmap(job
->bcs
),
111 static void backup_commit(Job
*job
)
113 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
114 if (s
->sync_bitmap
) {
115 backup_cleanup_sync_bitmap(s
, 0);
119 static void backup_abort(Job
*job
)
121 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
122 if (s
->sync_bitmap
) {
123 backup_cleanup_sync_bitmap(s
, -1);
127 static void backup_clean(Job
*job
)
129 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
130 bdrv_backup_top_drop(s
->backup_top
);
133 void backup_do_checkpoint(BlockJob
*job
, Error
**errp
)
135 BackupBlockJob
*backup_job
= container_of(job
, BackupBlockJob
, common
);
137 assert(block_job_driver(job
) == &backup_job_driver
);
139 if (backup_job
->sync_mode
!= MIRROR_SYNC_MODE_NONE
) {
140 error_setg(errp
, "The backup job only supports block checkpoint in"
145 bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job
->bcs
), 0,
149 static BlockErrorAction
backup_error_action(BackupBlockJob
*job
,
150 bool read
, int error
)
153 return block_job_error_action(&job
->common
, job
->on_source_error
,
156 return block_job_error_action(&job
->common
, job
->on_target_error
,
161 static bool coroutine_fn
yield_and_check(BackupBlockJob
*job
)
165 if (job_is_cancelled(&job
->common
.job
)) {
170 * We need to yield even for delay_ns = 0 so that bdrv_drain_all() can
171 * return. Without a yield, the VM would not reboot.
173 delay_ns
= block_job_ratelimit_get_delay(&job
->common
, job
->bytes_read
);
175 job_sleep_ns(&job
->common
.job
, delay_ns
);
177 if (job_is_cancelled(&job
->common
.job
)) {
184 static int coroutine_fn
backup_loop(BackupBlockJob
*job
)
188 BdrvDirtyBitmapIter
*bdbi
;
191 bdbi
= bdrv_dirty_iter_new(block_copy_dirty_bitmap(job
->bcs
));
192 while ((offset
= bdrv_dirty_iter_next(bdbi
)) != -1) {
194 if (yield_and_check(job
)) {
197 ret
= backup_do_cow(job
, offset
, job
->cluster_size
, &error_is_read
);
198 if (ret
< 0 && backup_error_action(job
, error_is_read
, -ret
) ==
199 BLOCK_ERROR_ACTION_REPORT
)
207 bdrv_dirty_iter_free(bdbi
);
211 static void backup_init_bcs_bitmap(BackupBlockJob
*job
)
215 BdrvDirtyBitmap
*bcs_bitmap
= block_copy_dirty_bitmap(job
->bcs
);
217 if (job
->sync_mode
== MIRROR_SYNC_MODE_BITMAP
) {
218 ret
= bdrv_dirty_bitmap_merge_internal(bcs_bitmap
, job
->sync_bitmap
,
222 if (job
->sync_mode
== MIRROR_SYNC_MODE_TOP
) {
224 * We can't hog the coroutine to initialize this thoroughly.
225 * Set a flag and resume work when we are able to yield safely.
227 block_copy_set_skip_unallocated(job
->bcs
, true);
229 bdrv_set_dirty_bitmap(bcs_bitmap
, 0, job
->len
);
232 estimate
= bdrv_get_dirty_count(bcs_bitmap
);
233 job_progress_set_remaining(&job
->common
.job
, estimate
);
236 static int coroutine_fn
backup_run(Job
*job
, Error
**errp
)
238 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
241 backup_init_bcs_bitmap(s
);
243 if (s
->sync_mode
== MIRROR_SYNC_MODE_TOP
) {
247 for (offset
= 0; offset
< s
->len
; ) {
248 if (yield_and_check(s
)) {
253 ret
= block_copy_reset_unallocated(s
->bcs
, offset
, &count
);
260 block_copy_set_skip_unallocated(s
->bcs
, false);
263 if (s
->sync_mode
== MIRROR_SYNC_MODE_NONE
) {
265 * All bits are set in bcs bitmap to allow any cluster to be copied.
266 * This does not actually require them to be copied.
268 while (!job_is_cancelled(job
)) {
270 * Yield until the job is cancelled. We just let our before_write
271 * notify callback service CoW requests.
276 ret
= backup_loop(s
);
283 static const BlockJobDriver backup_job_driver
= {
285 .instance_size
= sizeof(BackupBlockJob
),
286 .job_type
= JOB_TYPE_BACKUP
,
287 .free
= block_job_free
,
288 .user_resume
= block_job_user_resume
,
290 .commit
= backup_commit
,
291 .abort
= backup_abort
,
292 .clean
= backup_clean
,
296 static int64_t backup_calculate_cluster_size(BlockDriverState
*target
,
301 bool target_does_cow
= bdrv_backing_chain_next(target
);
304 * If there is no backing file on the target, we cannot rely on COW if our
305 * backup cluster size is smaller than the target cluster size. Even for
306 * targets with a backing file, try to avoid COW if possible.
308 ret
= bdrv_get_info(target
, &bdi
);
309 if (ret
== -ENOTSUP
&& !target_does_cow
) {
310 /* Cluster size is not defined */
311 warn_report("The target block device doesn't provide "
312 "information about the block size and it doesn't have a "
313 "backing file. The default block size of %u bytes is "
314 "used. If the actual block size of the target exceeds "
315 "this default, the backup may be unusable",
316 BACKUP_CLUSTER_SIZE_DEFAULT
);
317 return BACKUP_CLUSTER_SIZE_DEFAULT
;
318 } else if (ret
< 0 && !target_does_cow
) {
319 error_setg_errno(errp
, -ret
,
320 "Couldn't determine the cluster size of the target image, "
321 "which has no backing file");
322 error_append_hint(errp
,
323 "Aborting, since this may create an unusable destination image\n");
325 } else if (ret
< 0 && target_does_cow
) {
326 /* Not fatal; just trudge on ahead. */
327 return BACKUP_CLUSTER_SIZE_DEFAULT
;
330 return MAX(BACKUP_CLUSTER_SIZE_DEFAULT
, bdi
.cluster_size
);
333 BlockJob
*backup_job_create(const char *job_id
, BlockDriverState
*bs
,
334 BlockDriverState
*target
, int64_t speed
,
335 MirrorSyncMode sync_mode
, BdrvDirtyBitmap
*sync_bitmap
,
336 BitmapSyncMode bitmap_mode
,
338 const char *filter_node_name
,
340 BlockdevOnError on_source_error
,
341 BlockdevOnError on_target_error
,
343 BlockCompletionFunc
*cb
, void *opaque
,
344 JobTxn
*txn
, Error
**errp
)
346 int64_t len
, target_len
;
347 BackupBlockJob
*job
= NULL
;
348 int64_t cluster_size
;
349 BdrvRequestFlags write_flags
;
350 BlockDriverState
*backup_top
= NULL
;
351 BlockCopyState
*bcs
= NULL
;
356 /* QMP interface protects us from these cases */
357 assert(sync_mode
!= MIRROR_SYNC_MODE_INCREMENTAL
);
358 assert(sync_bitmap
|| sync_mode
!= MIRROR_SYNC_MODE_BITMAP
);
361 error_setg(errp
, "Source and target cannot be the same");
365 if (!bdrv_is_inserted(bs
)) {
366 error_setg(errp
, "Device is not inserted: %s",
367 bdrv_get_device_name(bs
));
371 if (!bdrv_is_inserted(target
)) {
372 error_setg(errp
, "Device is not inserted: %s",
373 bdrv_get_device_name(target
));
377 if (compress
&& !bdrv_supports_compressed_writes(target
)) {
378 error_setg(errp
, "Compression is not supported for this drive %s",
379 bdrv_get_device_name(target
));
383 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_BACKUP_SOURCE
, errp
)) {
387 if (bdrv_op_is_blocked(target
, BLOCK_OP_TYPE_BACKUP_TARGET
, errp
)) {
392 /* If we need to write to this bitmap, check that we can: */
393 if (bitmap_mode
!= BITMAP_SYNC_MODE_NEVER
&&
394 bdrv_dirty_bitmap_check(sync_bitmap
, BDRV_BITMAP_DEFAULT
, errp
)) {
398 /* Create a new bitmap, and freeze/disable this one. */
399 if (bdrv_dirty_bitmap_create_successor(sync_bitmap
, errp
) < 0) {
404 len
= bdrv_getlength(bs
);
406 error_setg_errno(errp
, -len
, "Unable to get length for '%s'",
407 bdrv_get_device_or_node_name(bs
));
411 target_len
= bdrv_getlength(target
);
412 if (target_len
< 0) {
413 error_setg_errno(errp
, -target_len
, "Unable to get length for '%s'",
414 bdrv_get_device_or_node_name(bs
));
418 if (target_len
!= len
) {
419 error_setg(errp
, "Source and target image have different sizes");
423 cluster_size
= backup_calculate_cluster_size(target
, errp
);
424 if (cluster_size
< 0) {
429 * If source is in backing chain of target assume that target is going to be
430 * used for "image fleecing", i.e. it should represent a kind of snapshot of
431 * source at backup-start point in time. And target is going to be read by
432 * somebody (for example, used as NBD export) during backup job.
434 * In this case, we need to add BDRV_REQ_SERIALISING write flag to avoid
435 * intersection of backup writes and third party reads from target,
436 * otherwise reading from target we may occasionally read already updated by
439 * For more information see commit f8d59dfb40bb and test
440 * tests/qemu-iotests/222
442 write_flags
= (bdrv_chain_contains(target
, bs
) ? BDRV_REQ_SERIALISING
: 0) |
443 (compress
? BDRV_REQ_WRITE_COMPRESSED
: 0),
445 backup_top
= bdrv_backup_top_append(bs
, target
, filter_node_name
,
447 write_flags
, &bcs
, errp
);
452 /* job->len is fixed, so we can't allow resize */
453 job
= block_job_create(job_id
, &backup_job_driver
, txn
, backup_top
,
455 speed
, creation_flags
, cb
, opaque
, errp
);
460 job
->backup_top
= backup_top
;
462 job
->on_source_error
= on_source_error
;
463 job
->on_target_error
= on_target_error
;
464 job
->sync_mode
= sync_mode
;
465 job
->sync_bitmap
= sync_bitmap
;
466 job
->bitmap_mode
= bitmap_mode
;
468 job
->cluster_size
= cluster_size
;
472 block_copy_set_progress_callback(bcs
, backup_progress_bytes_callback
, job
);
473 block_copy_set_progress_meter(bcs
, &job
->common
.job
.progress
);
475 /* Required permissions are already taken by backup-top target */
476 block_job_add_bdrv(&job
->common
, "target", target
, 0, BLK_PERM_ALL
,
483 bdrv_reclaim_dirty_bitmap(sync_bitmap
, NULL
);
486 bdrv_backup_top_drop(backup_top
);