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
;
53 static const BlockJobDriver backup_job_driver
;
55 static void backup_progress_bytes_callback(int64_t bytes
, void *opaque
)
57 BackupBlockJob
*s
= opaque
;
59 s
->bytes_read
+= bytes
;
62 static int coroutine_fn
backup_do_cow(BackupBlockJob
*job
,
63 int64_t offset
, uint64_t bytes
,
67 int64_t start
, end
; /* bytes */
69 start
= QEMU_ALIGN_DOWN(offset
, job
->cluster_size
);
70 end
= QEMU_ALIGN_UP(bytes
+ offset
, job
->cluster_size
);
72 trace_backup_do_cow_enter(job
, start
, offset
, bytes
);
74 ret
= block_copy(job
->bcs
, start
, end
- start
, error_is_read
);
76 trace_backup_do_cow_return(job
, offset
, bytes
, ret
);
81 static void backup_cleanup_sync_bitmap(BackupBlockJob
*job
, int ret
)
84 bool sync
= (((ret
== 0) || (job
->bitmap_mode
== BITMAP_SYNC_MODE_ALWAYS
)) \
85 && (job
->bitmap_mode
!= BITMAP_SYNC_MODE_NEVER
));
89 * We succeeded, or we always intended to sync the bitmap.
90 * Delete this bitmap and install the child.
92 bm
= bdrv_dirty_bitmap_abdicate(job
->sync_bitmap
, NULL
);
95 * We failed, or we never intended to sync the bitmap anyway.
96 * Merge the successor back into the parent, keeping all data.
98 bm
= bdrv_reclaim_dirty_bitmap(job
->sync_bitmap
, NULL
);
103 if (ret
< 0 && job
->bitmap_mode
== BITMAP_SYNC_MODE_ALWAYS
) {
104 /* If we failed and synced, merge in the bits we didn't copy: */
105 bdrv_dirty_bitmap_merge_internal(bm
, block_copy_dirty_bitmap(job
->bcs
),
110 static void backup_commit(Job
*job
)
112 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
113 if (s
->sync_bitmap
) {
114 backup_cleanup_sync_bitmap(s
, 0);
118 static void backup_abort(Job
*job
)
120 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
121 if (s
->sync_bitmap
) {
122 backup_cleanup_sync_bitmap(s
, -1);
126 static void backup_clean(Job
*job
)
128 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
129 bdrv_backup_top_drop(s
->backup_top
);
132 void backup_do_checkpoint(BlockJob
*job
, Error
**errp
)
134 BackupBlockJob
*backup_job
= container_of(job
, BackupBlockJob
, common
);
136 assert(block_job_driver(job
) == &backup_job_driver
);
138 if (backup_job
->sync_mode
!= MIRROR_SYNC_MODE_NONE
) {
139 error_setg(errp
, "The backup job only supports block checkpoint in"
144 bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job
->bcs
), 0,
148 static BlockErrorAction
backup_error_action(BackupBlockJob
*job
,
149 bool read
, int error
)
152 return block_job_error_action(&job
->common
, job
->on_source_error
,
155 return block_job_error_action(&job
->common
, job
->on_target_error
,
160 static bool coroutine_fn
yield_and_check(BackupBlockJob
*job
)
164 if (job_is_cancelled(&job
->common
.job
)) {
169 * We need to yield even for delay_ns = 0 so that bdrv_drain_all() can
170 * return. Without a yield, the VM would not reboot.
172 delay_ns
= block_job_ratelimit_get_delay(&job
->common
, job
->bytes_read
);
174 job_sleep_ns(&job
->common
.job
, delay_ns
);
176 if (job_is_cancelled(&job
->common
.job
)) {
183 static int coroutine_fn
backup_loop(BackupBlockJob
*job
)
187 BdrvDirtyBitmapIter
*bdbi
;
190 bdbi
= bdrv_dirty_iter_new(block_copy_dirty_bitmap(job
->bcs
));
191 while ((offset
= bdrv_dirty_iter_next(bdbi
)) != -1) {
193 if (yield_and_check(job
)) {
196 ret
= backup_do_cow(job
, offset
, job
->cluster_size
, &error_is_read
);
197 if (ret
< 0 && backup_error_action(job
, error_is_read
, -ret
) ==
198 BLOCK_ERROR_ACTION_REPORT
)
206 bdrv_dirty_iter_free(bdbi
);
210 static void backup_init_bcs_bitmap(BackupBlockJob
*job
)
214 BdrvDirtyBitmap
*bcs_bitmap
= block_copy_dirty_bitmap(job
->bcs
);
216 if (job
->sync_mode
== MIRROR_SYNC_MODE_BITMAP
) {
217 ret
= bdrv_dirty_bitmap_merge_internal(bcs_bitmap
, job
->sync_bitmap
,
221 if (job
->sync_mode
== MIRROR_SYNC_MODE_TOP
) {
223 * We can't hog the coroutine to initialize this thoroughly.
224 * Set a flag and resume work when we are able to yield safely.
226 block_copy_set_skip_unallocated(job
->bcs
, true);
228 bdrv_set_dirty_bitmap(bcs_bitmap
, 0, job
->len
);
231 estimate
= bdrv_get_dirty_count(bcs_bitmap
);
232 job_progress_set_remaining(&job
->common
.job
, estimate
);
235 static int coroutine_fn
backup_run(Job
*job
, Error
**errp
)
237 BackupBlockJob
*s
= container_of(job
, BackupBlockJob
, common
.job
);
240 backup_init_bcs_bitmap(s
);
242 if (s
->sync_mode
== MIRROR_SYNC_MODE_TOP
) {
246 for (offset
= 0; offset
< s
->len
; ) {
247 if (yield_and_check(s
)) {
252 ret
= block_copy_reset_unallocated(s
->bcs
, offset
, &count
);
259 block_copy_set_skip_unallocated(s
->bcs
, false);
262 if (s
->sync_mode
== MIRROR_SYNC_MODE_NONE
) {
264 * All bits are set in bcs bitmap to allow any cluster to be copied.
265 * This does not actually require them to be copied.
267 while (!job_is_cancelled(job
)) {
269 * Yield until the job is cancelled. We just let our before_write
270 * notify callback service CoW requests.
275 ret
= backup_loop(s
);
282 static const BlockJobDriver backup_job_driver
= {
284 .instance_size
= sizeof(BackupBlockJob
),
285 .job_type
= JOB_TYPE_BACKUP
,
286 .free
= block_job_free
,
287 .user_resume
= block_job_user_resume
,
289 .commit
= backup_commit
,
290 .abort
= backup_abort
,
291 .clean
= backup_clean
,
295 static int64_t backup_calculate_cluster_size(BlockDriverState
*target
,
302 * If there is no backing file on the target, we cannot rely on COW if our
303 * backup cluster size is smaller than the target cluster size. Even for
304 * targets with a backing file, try to avoid COW if possible.
306 ret
= bdrv_get_info(target
, &bdi
);
307 if (ret
== -ENOTSUP
&& !target
->backing
) {
308 /* Cluster size is not defined */
309 warn_report("The target block device doesn't provide "
310 "information about the block size and it doesn't have a "
311 "backing file. The default block size of %u bytes is "
312 "used. If the actual block size of the target exceeds "
313 "this default, the backup may be unusable",
314 BACKUP_CLUSTER_SIZE_DEFAULT
);
315 return BACKUP_CLUSTER_SIZE_DEFAULT
;
316 } else if (ret
< 0 && !target
->backing
) {
317 error_setg_errno(errp
, -ret
,
318 "Couldn't determine the cluster size of the target image, "
319 "which has no backing file");
320 error_append_hint(errp
,
321 "Aborting, since this may create an unusable destination image\n");
323 } else if (ret
< 0 && target
->backing
) {
324 /* Not fatal; just trudge on ahead. */
325 return BACKUP_CLUSTER_SIZE_DEFAULT
;
328 return MAX(BACKUP_CLUSTER_SIZE_DEFAULT
, bdi
.cluster_size
);
331 BlockJob
*backup_job_create(const char *job_id
, BlockDriverState
*bs
,
332 BlockDriverState
*target
, int64_t speed
,
333 MirrorSyncMode sync_mode
, BdrvDirtyBitmap
*sync_bitmap
,
334 BitmapSyncMode bitmap_mode
,
336 const char *filter_node_name
,
337 BlockdevOnError on_source_error
,
338 BlockdevOnError on_target_error
,
340 BlockCompletionFunc
*cb
, void *opaque
,
341 JobTxn
*txn
, Error
**errp
)
344 BackupBlockJob
*job
= NULL
;
345 int64_t cluster_size
;
346 BdrvRequestFlags write_flags
;
347 BlockDriverState
*backup_top
= NULL
;
348 BlockCopyState
*bcs
= NULL
;
353 /* QMP interface protects us from these cases */
354 assert(sync_mode
!= MIRROR_SYNC_MODE_INCREMENTAL
);
355 assert(sync_bitmap
|| sync_mode
!= MIRROR_SYNC_MODE_BITMAP
);
358 error_setg(errp
, "Source and target cannot be the same");
362 if (!bdrv_is_inserted(bs
)) {
363 error_setg(errp
, "Device is not inserted: %s",
364 bdrv_get_device_name(bs
));
368 if (!bdrv_is_inserted(target
)) {
369 error_setg(errp
, "Device is not inserted: %s",
370 bdrv_get_device_name(target
));
374 if (compress
&& !block_driver_can_compress(target
->drv
)) {
375 error_setg(errp
, "Compression is not supported for this drive %s",
376 bdrv_get_device_name(target
));
380 if (bdrv_op_is_blocked(bs
, BLOCK_OP_TYPE_BACKUP_SOURCE
, errp
)) {
384 if (bdrv_op_is_blocked(target
, BLOCK_OP_TYPE_BACKUP_TARGET
, errp
)) {
389 /* If we need to write to this bitmap, check that we can: */
390 if (bitmap_mode
!= BITMAP_SYNC_MODE_NEVER
&&
391 bdrv_dirty_bitmap_check(sync_bitmap
, BDRV_BITMAP_DEFAULT
, errp
)) {
395 /* Create a new bitmap, and freeze/disable this one. */
396 if (bdrv_dirty_bitmap_create_successor(sync_bitmap
, errp
) < 0) {
401 len
= bdrv_getlength(bs
);
403 error_setg_errno(errp
, -len
, "unable to get length for '%s'",
404 bdrv_get_device_name(bs
));
408 cluster_size
= backup_calculate_cluster_size(target
, errp
);
409 if (cluster_size
< 0) {
414 * If source is in backing chain of target assume that target is going to be
415 * used for "image fleecing", i.e. it should represent a kind of snapshot of
416 * source at backup-start point in time. And target is going to be read by
417 * somebody (for example, used as NBD export) during backup job.
419 * In this case, we need to add BDRV_REQ_SERIALISING write flag to avoid
420 * intersection of backup writes and third party reads from target,
421 * otherwise reading from target we may occasionally read already updated by
424 * For more information see commit f8d59dfb40bb and test
425 * tests/qemu-iotests/222
427 write_flags
= (bdrv_chain_contains(target
, bs
) ? BDRV_REQ_SERIALISING
: 0) |
428 (compress
? BDRV_REQ_WRITE_COMPRESSED
: 0),
430 backup_top
= bdrv_backup_top_append(bs
, target
, filter_node_name
,
431 cluster_size
, write_flags
, &bcs
, errp
);
436 /* job->len is fixed, so we can't allow resize */
437 job
= block_job_create(job_id
, &backup_job_driver
, txn
, backup_top
,
439 speed
, creation_flags
, cb
, opaque
, errp
);
444 job
->backup_top
= backup_top
;
446 job
->on_source_error
= on_source_error
;
447 job
->on_target_error
= on_target_error
;
448 job
->sync_mode
= sync_mode
;
449 job
->sync_bitmap
= sync_bitmap
;
450 job
->bitmap_mode
= bitmap_mode
;
452 job
->cluster_size
= cluster_size
;
455 block_copy_set_progress_callback(bcs
, backup_progress_bytes_callback
, job
);
456 block_copy_set_progress_meter(bcs
, &job
->common
.job
.progress
);
458 /* Required permissions are already taken by backup-top target */
459 block_job_add_bdrv(&job
->common
, "target", target
, 0, BLK_PERM_ALL
,
466 bdrv_reclaim_dirty_bitmap(sync_bitmap
, NULL
);
469 bdrv_backup_top_drop(backup_top
);