2 * Replication Block filter
4 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
5 * Copyright (c) 2016 Intel Corporation
6 * Copyright (c) 2016 FUJITSU LIMITED
9 * Wen Congyang <wency@cn.fujitsu.com>
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
15 #include "qemu/osdep.h"
16 #include "qemu/module.h"
17 #include "qemu/option.h"
18 #include "block/nbd.h"
19 #include "block/blockjob.h"
20 #include "block/block_int.h"
21 #include "block/block_backup.h"
22 #include "sysemu/block-backend.h"
23 #include "qapi/error.h"
24 #include "qapi/qmp/qdict.h"
25 #include "block/replication.h"
28 BLOCK_REPLICATION_NONE
, /* block replication is not started */
29 BLOCK_REPLICATION_RUNNING
, /* block replication is running */
30 BLOCK_REPLICATION_FAILOVER
, /* failover is running in background */
31 BLOCK_REPLICATION_FAILOVER_FAILED
, /* failover failed */
32 BLOCK_REPLICATION_DONE
, /* block replication is done */
35 typedef struct BDRVReplicationState
{
37 ReplicationStage stage
;
39 BdrvChild
*hidden_disk
;
40 BdrvChild
*secondary_disk
;
45 bool orig_hidden_read_only
;
46 bool orig_secondary_read_only
;
48 } BDRVReplicationState
;
50 static void replication_start(ReplicationState
*rs
, ReplicationMode mode
,
52 static void replication_do_checkpoint(ReplicationState
*rs
, Error
**errp
);
53 static void replication_get_error(ReplicationState
*rs
, Error
**errp
);
54 static void replication_stop(ReplicationState
*rs
, bool failover
,
57 #define REPLICATION_MODE "mode"
58 #define REPLICATION_TOP_ID "top-id"
59 static QemuOptsList replication_runtime_opts
= {
60 .name
= "replication",
61 .head
= QTAILQ_HEAD_INITIALIZER(replication_runtime_opts
.head
),
64 .name
= REPLICATION_MODE
,
65 .type
= QEMU_OPT_STRING
,
68 .name
= REPLICATION_TOP_ID
,
69 .type
= QEMU_OPT_STRING
,
75 static ReplicationOps replication_ops
= {
76 .start
= replication_start
,
77 .checkpoint
= replication_do_checkpoint
,
78 .get_error
= replication_get_error
,
79 .stop
= replication_stop
,
82 static int replication_open(BlockDriverState
*bs
, QDict
*options
,
83 int flags
, Error
**errp
)
86 BDRVReplicationState
*s
= bs
->opaque
;
87 QemuOpts
*opts
= NULL
;
91 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_of_bds
,
92 BDRV_CHILD_FILTERED
| BDRV_CHILD_PRIMARY
,
99 opts
= qemu_opts_create(&replication_runtime_opts
, NULL
, 0, &error_abort
);
100 if (!qemu_opts_absorb_qdict(opts
, options
, errp
)) {
104 mode
= qemu_opt_get(opts
, REPLICATION_MODE
);
106 error_setg(errp
, "Missing the option mode");
110 if (!strcmp(mode
, "primary")) {
111 s
->mode
= REPLICATION_MODE_PRIMARY
;
112 top_id
= qemu_opt_get(opts
, REPLICATION_TOP_ID
);
115 "The primary side does not support option top-id");
118 } else if (!strcmp(mode
, "secondary")) {
119 s
->mode
= REPLICATION_MODE_SECONDARY
;
120 top_id
= qemu_opt_get(opts
, REPLICATION_TOP_ID
);
121 s
->top_id
= g_strdup(top_id
);
123 error_setg(errp
, "Missing the option top-id");
128 "The option mode's value should be primary or secondary");
132 s
->rs
= replication_new(bs
, &replication_ops
);
141 static void replication_close(BlockDriverState
*bs
)
143 BDRVReplicationState
*s
= bs
->opaque
;
146 if (s
->stage
== BLOCK_REPLICATION_RUNNING
) {
147 replication_stop(s
->rs
, false, NULL
);
149 if (s
->stage
== BLOCK_REPLICATION_FAILOVER
) {
150 commit_job
= &s
->commit_job
->job
;
151 assert(commit_job
->aio_context
== qemu_get_current_aio_context());
152 job_cancel_sync(commit_job
);
155 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
159 replication_remove(s
->rs
);
162 static void replication_child_perm(BlockDriverState
*bs
, BdrvChild
*c
,
164 BlockReopenQueue
*reopen_queue
,
165 uint64_t perm
, uint64_t shared
,
166 uint64_t *nperm
, uint64_t *nshared
)
168 if (role
& BDRV_CHILD_PRIMARY
) {
169 *nperm
= BLK_PERM_CONSISTENT_READ
;
174 if ((bs
->open_flags
& (BDRV_O_INACTIVE
| BDRV_O_RDWR
)) == BDRV_O_RDWR
) {
175 *nperm
|= BLK_PERM_WRITE
;
177 *nshared
= BLK_PERM_CONSISTENT_READ
179 | BLK_PERM_WRITE_UNCHANGED
;
183 static int64_t replication_getlength(BlockDriverState
*bs
)
185 return bdrv_getlength(bs
->file
->bs
);
188 static int replication_get_io_status(BDRVReplicationState
*s
)
191 case BLOCK_REPLICATION_NONE
:
193 case BLOCK_REPLICATION_RUNNING
:
195 case BLOCK_REPLICATION_FAILOVER
:
196 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 0;
197 case BLOCK_REPLICATION_FAILOVER_FAILED
:
198 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 1;
199 case BLOCK_REPLICATION_DONE
:
201 * active commit job completes, and active disk and secondary_disk
202 * is swapped, so we can operate bs->file directly
204 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 0;
210 static int replication_return_value(BDRVReplicationState
*s
, int ret
)
212 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
224 static coroutine_fn
int replication_co_readv(BlockDriverState
*bs
,
226 int remaining_sectors
,
229 BDRVReplicationState
*s
= bs
->opaque
;
232 if (s
->mode
== REPLICATION_MODE_PRIMARY
) {
233 /* We only use it to forward primary write requests */
237 ret
= replication_get_io_status(s
);
242 ret
= bdrv_co_preadv(bs
->file
, sector_num
* BDRV_SECTOR_SIZE
,
243 remaining_sectors
* BDRV_SECTOR_SIZE
, qiov
, 0);
245 return replication_return_value(s
, ret
);
248 static coroutine_fn
int replication_co_writev(BlockDriverState
*bs
,
250 int remaining_sectors
,
254 BDRVReplicationState
*s
= bs
->opaque
;
255 QEMUIOVector hd_qiov
;
256 uint64_t bytes_done
= 0;
257 BdrvChild
*top
= bs
->file
;
258 BdrvChild
*base
= s
->secondary_disk
;
264 ret
= replication_get_io_status(s
);
270 ret
= bdrv_co_pwritev(top
, sector_num
* BDRV_SECTOR_SIZE
,
271 remaining_sectors
* BDRV_SECTOR_SIZE
, qiov
, 0);
272 return replication_return_value(s
, ret
);
276 * Failover failed, only write to active disk if the sectors
277 * have already been allocated in active disk/hidden disk.
279 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
280 while (remaining_sectors
> 0) {
283 ret
= bdrv_is_allocated_above(top
->bs
, base
->bs
, false,
284 sector_num
* BDRV_SECTOR_SIZE
,
285 remaining_sectors
* BDRV_SECTOR_SIZE
,
291 assert(QEMU_IS_ALIGNED(count
, BDRV_SECTOR_SIZE
));
292 n
= count
>> BDRV_SECTOR_BITS
;
293 qemu_iovec_reset(&hd_qiov
);
294 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, count
);
296 target
= ret
? top
: base
;
297 ret
= bdrv_co_pwritev(target
, sector_num
* BDRV_SECTOR_SIZE
,
298 n
* BDRV_SECTOR_SIZE
, &hd_qiov
, 0);
303 remaining_sectors
-= n
;
309 qemu_iovec_destroy(&hd_qiov
);
314 static void secondary_do_checkpoint(BlockDriverState
*bs
, Error
**errp
)
316 BDRVReplicationState
*s
= bs
->opaque
;
317 BdrvChild
*active_disk
= bs
->file
;
318 Error
*local_err
= NULL
;
321 if (!s
->backup_job
) {
322 error_setg(errp
, "Backup job was cancelled unexpectedly");
326 backup_do_checkpoint(s
->backup_job
, &local_err
);
328 error_propagate(errp
, local_err
);
332 if (!active_disk
->bs
->drv
) {
333 error_setg(errp
, "Active disk %s is ejected",
334 active_disk
->bs
->node_name
);
338 ret
= bdrv_make_empty(active_disk
, errp
);
343 if (!s
->hidden_disk
->bs
->drv
) {
344 error_setg(errp
, "Hidden disk %s is ejected",
345 s
->hidden_disk
->bs
->node_name
);
349 BlockBackend
*blk
= blk_new(qemu_get_current_aio_context(),
350 BLK_PERM_WRITE
, BLK_PERM_ALL
);
351 blk_insert_bs(blk
, s
->hidden_disk
->bs
, &local_err
);
353 error_propagate(errp
, local_err
);
358 ret
= blk_make_empty(blk
, errp
);
365 /* This function is supposed to be called twice:
366 * first with writable = true, then with writable = false.
367 * The first call puts s->hidden_disk and s->secondary_disk in
368 * r/w mode, and the second puts them back in their original state.
370 static void reopen_backing_file(BlockDriverState
*bs
, bool writable
,
373 BDRVReplicationState
*s
= bs
->opaque
;
374 BdrvChild
*hidden_disk
, *secondary_disk
;
375 BlockReopenQueue
*reopen_queue
= NULL
;
378 * s->hidden_disk and s->secondary_disk may not be set yet, as they will
379 * only be set after the children are writable.
381 hidden_disk
= bs
->file
->bs
->backing
;
382 secondary_disk
= hidden_disk
->bs
->backing
;
385 s
->orig_hidden_read_only
= bdrv_is_read_only(hidden_disk
->bs
);
386 s
->orig_secondary_read_only
= bdrv_is_read_only(secondary_disk
->bs
);
389 bdrv_subtree_drained_begin(hidden_disk
->bs
);
390 bdrv_subtree_drained_begin(secondary_disk
->bs
);
392 if (s
->orig_hidden_read_only
) {
393 QDict
*opts
= qdict_new();
394 qdict_put_bool(opts
, BDRV_OPT_READ_ONLY
, !writable
);
395 reopen_queue
= bdrv_reopen_queue(reopen_queue
, hidden_disk
->bs
,
399 if (s
->orig_secondary_read_only
) {
400 QDict
*opts
= qdict_new();
401 qdict_put_bool(opts
, BDRV_OPT_READ_ONLY
, !writable
);
402 reopen_queue
= bdrv_reopen_queue(reopen_queue
, secondary_disk
->bs
,
407 AioContext
*ctx
= bdrv_get_aio_context(bs
);
408 if (ctx
!= qemu_get_aio_context()) {
409 aio_context_release(ctx
);
411 bdrv_reopen_multiple(reopen_queue
, errp
);
412 if (ctx
!= qemu_get_aio_context()) {
413 aio_context_acquire(ctx
);
417 bdrv_subtree_drained_end(hidden_disk
->bs
);
418 bdrv_subtree_drained_end(secondary_disk
->bs
);
421 static void backup_job_cleanup(BlockDriverState
*bs
)
423 BDRVReplicationState
*s
= bs
->opaque
;
424 BlockDriverState
*top_bs
;
426 s
->backup_job
= NULL
;
428 top_bs
= bdrv_lookup_bs(s
->top_id
, s
->top_id
, NULL
);
432 bdrv_op_unblock_all(top_bs
, s
->blocker
);
433 error_free(s
->blocker
);
434 reopen_backing_file(bs
, false, NULL
);
437 static void backup_job_completed(void *opaque
, int ret
)
439 BlockDriverState
*bs
= opaque
;
440 BDRVReplicationState
*s
= bs
->opaque
;
442 if (s
->stage
!= BLOCK_REPLICATION_FAILOVER
) {
443 /* The backup job is cancelled unexpectedly */
447 backup_job_cleanup(bs
);
450 static bool check_top_bs(BlockDriverState
*top_bs
, BlockDriverState
*bs
)
454 /* The bs itself is the top_bs */
459 /* Iterate over top_bs's children */
460 QLIST_FOREACH(child
, &top_bs
->children
, next
) {
461 if (child
->bs
== bs
|| check_top_bs(child
->bs
, bs
)) {
469 static void replication_start(ReplicationState
*rs
, ReplicationMode mode
,
472 BlockDriverState
*bs
= rs
->opaque
;
473 BDRVReplicationState
*s
;
474 BlockDriverState
*top_bs
;
475 BdrvChild
*active_disk
, *hidden_disk
, *secondary_disk
;
476 int64_t active_length
, hidden_length
, disk_length
;
477 AioContext
*aio_context
;
478 Error
*local_err
= NULL
;
479 BackupPerf perf
= { .use_copy_range
= true, .max_workers
= 1 };
481 aio_context
= bdrv_get_aio_context(bs
);
482 aio_context_acquire(aio_context
);
485 if (s
->stage
== BLOCK_REPLICATION_DONE
||
486 s
->stage
== BLOCK_REPLICATION_FAILOVER
) {
488 * This case happens when a secondary is promoted to primary.
489 * Ignore the request because the secondary side of replication
490 * doesn't have to do anything anymore.
492 aio_context_release(aio_context
);
496 if (s
->stage
!= BLOCK_REPLICATION_NONE
) {
497 error_setg(errp
, "Block replication is running or done");
498 aio_context_release(aio_context
);
502 if (s
->mode
!= mode
) {
503 error_setg(errp
, "The parameter mode's value is invalid, needs %d,"
504 " but got %d", s
->mode
, mode
);
505 aio_context_release(aio_context
);
510 case REPLICATION_MODE_PRIMARY
:
512 case REPLICATION_MODE_SECONDARY
:
513 active_disk
= bs
->file
;
514 if (!active_disk
|| !active_disk
->bs
|| !active_disk
->bs
->backing
) {
515 error_setg(errp
, "Active disk doesn't have backing file");
516 aio_context_release(aio_context
);
520 hidden_disk
= active_disk
->bs
->backing
;
521 if (!hidden_disk
->bs
|| !hidden_disk
->bs
->backing
) {
522 error_setg(errp
, "Hidden disk doesn't have backing file");
523 aio_context_release(aio_context
);
527 secondary_disk
= hidden_disk
->bs
->backing
;
528 if (!secondary_disk
->bs
|| !bdrv_has_blk(secondary_disk
->bs
)) {
529 error_setg(errp
, "The secondary disk doesn't have block backend");
530 aio_context_release(aio_context
);
534 /* verify the length */
535 active_length
= bdrv_getlength(active_disk
->bs
);
536 hidden_length
= bdrv_getlength(hidden_disk
->bs
);
537 disk_length
= bdrv_getlength(secondary_disk
->bs
);
538 if (active_length
< 0 || hidden_length
< 0 || disk_length
< 0 ||
539 active_length
!= hidden_length
|| hidden_length
!= disk_length
) {
540 error_setg(errp
, "Active disk, hidden disk, secondary disk's length"
541 " are not the same");
542 aio_context_release(aio_context
);
546 /* Must be true, or the bdrv_getlength() calls would have failed */
547 assert(active_disk
->bs
->drv
&& hidden_disk
->bs
->drv
);
549 if (!active_disk
->bs
->drv
->bdrv_make_empty
||
550 !hidden_disk
->bs
->drv
->bdrv_make_empty
) {
552 "Active disk or hidden disk doesn't support make_empty");
553 aio_context_release(aio_context
);
557 /* reopen the backing file in r/w mode */
558 reopen_backing_file(bs
, true, &local_err
);
560 error_propagate(errp
, local_err
);
561 aio_context_release(aio_context
);
565 bdrv_ref(hidden_disk
->bs
);
566 s
->hidden_disk
= bdrv_attach_child(bs
, hidden_disk
->bs
, "hidden disk",
567 &child_of_bds
, BDRV_CHILD_DATA
,
570 error_propagate(errp
, local_err
);
571 aio_context_release(aio_context
);
575 bdrv_ref(secondary_disk
->bs
);
576 s
->secondary_disk
= bdrv_attach_child(bs
, secondary_disk
->bs
,
577 "secondary disk", &child_of_bds
,
578 BDRV_CHILD_DATA
, &local_err
);
580 error_propagate(errp
, local_err
);
581 aio_context_release(aio_context
);
585 /* start backup job now */
586 error_setg(&s
->blocker
,
587 "Block device is in use by internal backup job");
589 top_bs
= bdrv_lookup_bs(s
->top_id
, s
->top_id
, NULL
);
590 if (!top_bs
|| !bdrv_is_root_node(top_bs
) ||
591 !check_top_bs(top_bs
, bs
)) {
592 error_setg(errp
, "No top_bs or it is invalid");
593 reopen_backing_file(bs
, false, NULL
);
594 aio_context_release(aio_context
);
597 bdrv_op_block_all(top_bs
, s
->blocker
);
598 bdrv_op_unblock(top_bs
, BLOCK_OP_TYPE_DATAPLANE
, s
->blocker
);
600 s
->backup_job
= backup_job_create(
601 NULL
, s
->secondary_disk
->bs
, s
->hidden_disk
->bs
,
602 0, MIRROR_SYNC_MODE_NONE
, NULL
, 0, false, NULL
,
604 BLOCKDEV_ON_ERROR_REPORT
,
605 BLOCKDEV_ON_ERROR_REPORT
, JOB_INTERNAL
,
606 backup_job_completed
, bs
, NULL
, &local_err
);
608 error_propagate(errp
, local_err
);
609 backup_job_cleanup(bs
);
610 aio_context_release(aio_context
);
613 job_start(&s
->backup_job
->job
);
616 aio_context_release(aio_context
);
620 s
->stage
= BLOCK_REPLICATION_RUNNING
;
622 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
623 secondary_do_checkpoint(bs
, errp
);
627 aio_context_release(aio_context
);
630 static void replication_do_checkpoint(ReplicationState
*rs
, Error
**errp
)
632 BlockDriverState
*bs
= rs
->opaque
;
633 BDRVReplicationState
*s
;
634 AioContext
*aio_context
;
636 aio_context
= bdrv_get_aio_context(bs
);
637 aio_context_acquire(aio_context
);
640 if (s
->stage
== BLOCK_REPLICATION_DONE
||
641 s
->stage
== BLOCK_REPLICATION_FAILOVER
) {
643 * This case happens when a secondary was promoted to primary.
644 * Ignore the request because the secondary side of replication
645 * doesn't have to do anything anymore.
647 aio_context_release(aio_context
);
651 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
652 secondary_do_checkpoint(bs
, errp
);
654 aio_context_release(aio_context
);
657 static void replication_get_error(ReplicationState
*rs
, Error
**errp
)
659 BlockDriverState
*bs
= rs
->opaque
;
660 BDRVReplicationState
*s
;
661 AioContext
*aio_context
;
663 aio_context
= bdrv_get_aio_context(bs
);
664 aio_context_acquire(aio_context
);
667 if (s
->stage
== BLOCK_REPLICATION_NONE
) {
668 error_setg(errp
, "Block replication is not running");
669 aio_context_release(aio_context
);
674 error_setg(errp
, "I/O error occurred");
675 aio_context_release(aio_context
);
678 aio_context_release(aio_context
);
681 static void replication_done(void *opaque
, int ret
)
683 BlockDriverState
*bs
= opaque
;
684 BDRVReplicationState
*s
= bs
->opaque
;
687 s
->stage
= BLOCK_REPLICATION_DONE
;
689 bdrv_unref_child(bs
, s
->secondary_disk
);
690 s
->secondary_disk
= NULL
;
691 bdrv_unref_child(bs
, s
->hidden_disk
);
692 s
->hidden_disk
= NULL
;
695 s
->stage
= BLOCK_REPLICATION_FAILOVER_FAILED
;
700 static void replication_stop(ReplicationState
*rs
, bool failover
, Error
**errp
)
702 BlockDriverState
*bs
= rs
->opaque
;
703 BDRVReplicationState
*s
;
704 AioContext
*aio_context
;
706 aio_context
= bdrv_get_aio_context(bs
);
707 aio_context_acquire(aio_context
);
710 if (s
->stage
== BLOCK_REPLICATION_DONE
||
711 s
->stage
== BLOCK_REPLICATION_FAILOVER
) {
713 * This case happens when a secondary was promoted to primary.
714 * Ignore the request because the secondary side of replication
715 * doesn't have to do anything anymore.
717 aio_context_release(aio_context
);
721 if (s
->stage
!= BLOCK_REPLICATION_RUNNING
) {
722 error_setg(errp
, "Block replication is not running");
723 aio_context_release(aio_context
);
728 case REPLICATION_MODE_PRIMARY
:
729 s
->stage
= BLOCK_REPLICATION_DONE
;
732 case REPLICATION_MODE_SECONDARY
:
734 * This BDS will be closed, and the job should be completed
735 * before the BDS is closed, because we will access hidden
736 * disk, secondary disk in backup_job_completed().
739 job_cancel_sync(&s
->backup_job
->job
);
743 secondary_do_checkpoint(bs
, errp
);
744 s
->stage
= BLOCK_REPLICATION_DONE
;
745 aio_context_release(aio_context
);
749 s
->stage
= BLOCK_REPLICATION_FAILOVER
;
750 s
->commit_job
= commit_active_start(
751 NULL
, bs
->file
->bs
, s
->secondary_disk
->bs
,
752 JOB_INTERNAL
, 0, BLOCKDEV_ON_ERROR_REPORT
,
753 NULL
, replication_done
, bs
, true, errp
);
756 aio_context_release(aio_context
);
759 aio_context_release(aio_context
);
762 static const char *const replication_strong_runtime_opts
[] = {
769 static BlockDriver bdrv_replication
= {
770 .format_name
= "replication",
771 .instance_size
= sizeof(BDRVReplicationState
),
773 .bdrv_open
= replication_open
,
774 .bdrv_close
= replication_close
,
775 .bdrv_child_perm
= replication_child_perm
,
777 .bdrv_getlength
= replication_getlength
,
778 .bdrv_co_readv
= replication_co_readv
,
779 .bdrv_co_writev
= replication_co_writev
,
783 .has_variable_length
= true,
784 .strong_runtime_opts
= replication_strong_runtime_opts
,
787 static void bdrv_replication_init(void)
789 bdrv_register(&bdrv_replication
);
792 block_init(bdrv_replication_init
);