1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include "qemu/osdep.h"
16
17#include "trace.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"
30
31#include "block/backup-top.h"
32
33#define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16)
34
35typedef struct BackupBlockJob {
36 BlockJob common;
37 BlockDriverState *backup_top;
38 BlockDriverState *source_bs;
39
40 BdrvDirtyBitmap *sync_bitmap;
41
42 MirrorSyncMode sync_mode;
43 BitmapSyncMode bitmap_mode;
44 BlockdevOnError on_source_error;
45 BlockdevOnError on_target_error;
46 uint64_t len;
47 uint64_t bytes_read;
48 int64_t cluster_size;
49
50 BlockCopyState *bcs;
51} BackupBlockJob;
52
53static const BlockJobDriver backup_job_driver;
54
55static void backup_progress_bytes_callback(int64_t bytes, void *opaque)
56{
57 BackupBlockJob *s = opaque;
58
59 s->bytes_read += bytes;
60}
61
62static int coroutine_fn backup_do_cow(BackupBlockJob *job,
63 int64_t offset, uint64_t bytes,
64 bool *error_is_read)
65{
66 int ret = 0;
67 int64_t start, end;
68
69 start = QEMU_ALIGN_DOWN(offset, job->cluster_size);
70 end = QEMU_ALIGN_UP(bytes + offset, job->cluster_size);
71
72 trace_backup_do_cow_enter(job, start, offset, bytes);
73
74 ret = block_copy(job->bcs, start, end - start, error_is_read);
75
76 trace_backup_do_cow_return(job, offset, bytes, ret);
77
78 return ret;
79}
80
81static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
82{
83 BdrvDirtyBitmap *bm;
84 bool sync = (((ret == 0) || (job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS)) \
85 && (job->bitmap_mode != BITMAP_SYNC_MODE_NEVER));
86
87 if (sync) {
88
89
90
91
92 bm = bdrv_dirty_bitmap_abdicate(job->sync_bitmap, NULL);
93 } else {
94
95
96
97
98 bm = bdrv_reclaim_dirty_bitmap(job->sync_bitmap, NULL);
99 }
100
101 assert(bm);
102
103 if (ret < 0 && job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS) {
104
105 bdrv_dirty_bitmap_merge_internal(bm, job->bcs->copy_bitmap,
106 NULL, true);
107 }
108}
109
110static void backup_commit(Job *job)
111{
112 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
113 if (s->sync_bitmap) {
114 backup_cleanup_sync_bitmap(s, 0);
115 }
116}
117
118static void backup_abort(Job *job)
119{
120 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
121 if (s->sync_bitmap) {
122 backup_cleanup_sync_bitmap(s, -1);
123 }
124}
125
126static void backup_clean(Job *job)
127{
128 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
129
130 bdrv_backup_top_drop(s->backup_top);
131}
132
133void backup_do_checkpoint(BlockJob *job, Error **errp)
134{
135 BackupBlockJob *backup_job = container_of(job, BackupBlockJob, common);
136
137 assert(block_job_driver(job) == &backup_job_driver);
138
139 if (backup_job->sync_mode != MIRROR_SYNC_MODE_NONE) {
140 error_setg(errp, "The backup job only supports block checkpoint in"
141 " sync=none mode");
142 return;
143 }
144
145 bdrv_set_dirty_bitmap(backup_job->bcs->copy_bitmap, 0, backup_job->len);
146}
147
148static BlockErrorAction backup_error_action(BackupBlockJob *job,
149 bool read, int error)
150{
151 if (read) {
152 return block_job_error_action(&job->common, job->on_source_error,
153 true, error);
154 } else {
155 return block_job_error_action(&job->common, job->on_target_error,
156 false, error);
157 }
158}
159
160static bool coroutine_fn yield_and_check(BackupBlockJob *job)
161{
162 uint64_t delay_ns;
163
164 if (job_is_cancelled(&job->common.job)) {
165 return true;
166 }
167
168
169
170
171
172 delay_ns = block_job_ratelimit_get_delay(&job->common, job->bytes_read);
173 job->bytes_read = 0;
174 job_sleep_ns(&job->common.job, delay_ns);
175
176 if (job_is_cancelled(&job->common.job)) {
177 return true;
178 }
179
180 return false;
181}
182
183static int coroutine_fn backup_loop(BackupBlockJob *job)
184{
185 bool error_is_read;
186 int64_t offset;
187 BdrvDirtyBitmapIter *bdbi;
188 int ret = 0;
189
190 bdbi = bdrv_dirty_iter_new(job->bcs->copy_bitmap);
191 while ((offset = bdrv_dirty_iter_next(bdbi)) != -1) {
192 do {
193 if (yield_and_check(job)) {
194 goto out;
195 }
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)
199 {
200 goto out;
201 }
202 } while (ret < 0);
203 }
204
205 out:
206 bdrv_dirty_iter_free(bdbi);
207 return ret;
208}
209
210static void backup_init_copy_bitmap(BackupBlockJob *job)
211{
212 bool ret;
213 uint64_t estimate;
214
215 if (job->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
216 ret = bdrv_dirty_bitmap_merge_internal(job->bcs->copy_bitmap,
217 job->sync_bitmap,
218 NULL, true);
219 assert(ret);
220 } else {
221 if (job->sync_mode == MIRROR_SYNC_MODE_TOP) {
222
223
224
225
226 job->bcs->skip_unallocated = true;
227 }
228 bdrv_set_dirty_bitmap(job->bcs->copy_bitmap, 0, job->len);
229 }
230
231 estimate = bdrv_get_dirty_count(job->bcs->copy_bitmap);
232 job_progress_set_remaining(&job->common.job, estimate);
233}
234
235static int coroutine_fn backup_run(Job *job, Error **errp)
236{
237 BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
238 int ret = 0;
239
240 backup_init_copy_bitmap(s);
241
242 if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
243 int64_t offset = 0;
244 int64_t count;
245
246 for (offset = 0; offset < s->len; ) {
247 if (yield_and_check(s)) {
248 ret = -ECANCELED;
249 goto out;
250 }
251
252 ret = block_copy_reset_unallocated(s->bcs, offset, &count);
253 if (ret < 0) {
254 goto out;
255 }
256
257 offset += count;
258 }
259 s->bcs->skip_unallocated = false;
260 }
261
262 if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
263
264
265
266
267 while (!job_is_cancelled(job)) {
268
269
270
271
272 job_yield(job);
273 }
274 } else {
275 ret = backup_loop(s);
276 }
277
278 out:
279 return ret;
280}
281
282static const BlockJobDriver backup_job_driver = {
283 .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,
288 .run = backup_run,
289 .commit = backup_commit,
290 .abort = backup_abort,
291 .clean = backup_clean,
292 }
293};
294
295static int64_t backup_calculate_cluster_size(BlockDriverState *target,
296 Error **errp)
297{
298 int ret;
299 BlockDriverInfo bdi;
300
301
302
303
304
305
306 ret = bdrv_get_info(target, &bdi);
307 if (ret == -ENOTSUP && !target->backing) {
308
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");
322 return ret;
323 } else if (ret < 0 && target->backing) {
324
325 return BACKUP_CLUSTER_SIZE_DEFAULT;
326 }
327
328 return MAX(BACKUP_CLUSTER_SIZE_DEFAULT, bdi.cluster_size);
329}
330
331BlockJob *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,
335 bool compress,
336 const char *filter_node_name,
337 BlockdevOnError on_source_error,
338 BlockdevOnError on_target_error,
339 int creation_flags,
340 BlockCompletionFunc *cb, void *opaque,
341 JobTxn *txn, Error **errp)
342{
343 int64_t len;
344 BackupBlockJob *job = NULL;
345 int64_t cluster_size;
346 BdrvRequestFlags write_flags;
347 BlockDriverState *backup_top = NULL;
348 BlockCopyState *bcs = NULL;
349
350 assert(bs);
351 assert(target);
352
353
354 assert(sync_mode != MIRROR_SYNC_MODE_INCREMENTAL);
355 assert(sync_bitmap || sync_mode != MIRROR_SYNC_MODE_BITMAP);
356
357 if (bs == target) {
358 error_setg(errp, "Source and target cannot be the same");
359 return NULL;
360 }
361
362 if (!bdrv_is_inserted(bs)) {
363 error_setg(errp, "Device is not inserted: %s",
364 bdrv_get_device_name(bs));
365 return NULL;
366 }
367
368 if (!bdrv_is_inserted(target)) {
369 error_setg(errp, "Device is not inserted: %s",
370 bdrv_get_device_name(target));
371 return NULL;
372 }
373
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));
377 return NULL;
378 }
379
380 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
381 return NULL;
382 }
383
384 if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) {
385 return NULL;
386 }
387
388 if (sync_bitmap) {
389
390 if (bitmap_mode != BITMAP_SYNC_MODE_NEVER &&
391 bdrv_dirty_bitmap_check(sync_bitmap, BDRV_BITMAP_DEFAULT, errp)) {
392 return NULL;
393 }
394
395
396 if (bdrv_dirty_bitmap_create_successor(sync_bitmap, errp) < 0) {
397 return NULL;
398 }
399 }
400
401 len = bdrv_getlength(bs);
402 if (len < 0) {
403 error_setg_errno(errp, -len, "unable to get length for '%s'",
404 bdrv_get_device_name(bs));
405 goto error;
406 }
407
408 cluster_size = backup_calculate_cluster_size(target, errp);
409 if (cluster_size < 0) {
410 goto error;
411 }
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427 write_flags = (bdrv_chain_contains(target, bs) ? BDRV_REQ_SERIALISING : 0) |
428 (compress ? BDRV_REQ_WRITE_COMPRESSED : 0),
429
430 backup_top = bdrv_backup_top_append(bs, target, filter_node_name,
431 cluster_size, write_flags, &bcs, errp);
432 if (!backup_top) {
433 goto error;
434 }
435
436
437 job = block_job_create(job_id, &backup_job_driver, txn, backup_top,
438 0, BLK_PERM_ALL,
439 speed, creation_flags, cb, opaque, errp);
440 if (!job) {
441 goto error;
442 }
443
444 job->backup_top = backup_top;
445 job->source_bs = bs;
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;
451 job->bcs = bcs;
452 job->cluster_size = cluster_size;
453 job->len = len;
454
455 block_copy_set_progress_callback(bcs, backup_progress_bytes_callback, job);
456 block_copy_set_progress_meter(bcs, &job->common.job.progress);
457
458
459 block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
460 &error_abort);
461
462 return &job->common;
463
464 error:
465 if (sync_bitmap) {
466 bdrv_reclaim_dirty_bitmap(sync_bitmap, NULL);
467 }
468 if (backup_top) {
469 bdrv_backup_top_drop(backup_top);
470 }
471
472 return NULL;
473}
474