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 "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
;
38 BdrvChild
*active_disk
;
39 BdrvChild
*hidden_disk
;
40 BdrvChild
*secondary_disk
;
44 bool orig_hidden_read_only
;
45 bool orig_secondary_read_only
;
47 } BDRVReplicationState
;
49 static void replication_start(ReplicationState
*rs
, ReplicationMode mode
,
51 static void replication_do_checkpoint(ReplicationState
*rs
, Error
**errp
);
52 static void replication_get_error(ReplicationState
*rs
, Error
**errp
);
53 static void replication_stop(ReplicationState
*rs
, bool failover
,
56 #define REPLICATION_MODE "mode"
57 #define REPLICATION_TOP_ID "top-id"
58 static QemuOptsList replication_runtime_opts
= {
59 .name
= "replication",
60 .head
= QTAILQ_HEAD_INITIALIZER(replication_runtime_opts
.head
),
63 .name
= REPLICATION_MODE
,
64 .type
= QEMU_OPT_STRING
,
67 .name
= REPLICATION_TOP_ID
,
68 .type
= QEMU_OPT_STRING
,
74 static ReplicationOps replication_ops
= {
75 .start
= replication_start
,
76 .checkpoint
= replication_do_checkpoint
,
77 .get_error
= replication_get_error
,
78 .stop
= replication_stop
,
81 static int replication_open(BlockDriverState
*bs
, QDict
*options
,
82 int flags
, Error
**errp
)
85 BDRVReplicationState
*s
= bs
->opaque
;
86 Error
*local_err
= NULL
;
87 QemuOpts
*opts
= NULL
;
91 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
98 opts
= qemu_opts_create(&replication_runtime_opts
, NULL
, 0, &error_abort
);
99 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
104 mode
= qemu_opt_get(opts
, REPLICATION_MODE
);
106 error_setg(&local_err
, "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
);
114 error_setg(&local_err
, "The primary side does not support option top-id");
117 } else if (!strcmp(mode
, "secondary")) {
118 s
->mode
= REPLICATION_MODE_SECONDARY
;
119 top_id
= qemu_opt_get(opts
, REPLICATION_TOP_ID
);
120 s
->top_id
= g_strdup(top_id
);
122 error_setg(&local_err
, "Missing the option top-id");
126 error_setg(&local_err
,
127 "The option mode's value should be primary or secondary");
131 s
->rs
= replication_new(bs
, &replication_ops
);
137 error_propagate(errp
, local_err
);
142 static void replication_close(BlockDriverState
*bs
)
144 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 job_cancel_sync(&s
->active_disk
->bs
->job
->job
);
153 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
157 replication_remove(s
->rs
);
160 static void replication_child_perm(BlockDriverState
*bs
, BdrvChild
*c
,
161 const BdrvChildRole
*role
,
162 BlockReopenQueue
*reopen_queue
,
163 uint64_t perm
, uint64_t shared
,
164 uint64_t *nperm
, uint64_t *nshared
)
166 *nperm
= BLK_PERM_CONSISTENT_READ
;
167 if ((bs
->open_flags
& (BDRV_O_INACTIVE
| BDRV_O_RDWR
)) == BDRV_O_RDWR
) {
168 *nperm
|= BLK_PERM_WRITE
;
170 *nshared
= BLK_PERM_CONSISTENT_READ \
172 | BLK_PERM_WRITE_UNCHANGED
;
176 static int64_t replication_getlength(BlockDriverState
*bs
)
178 return bdrv_getlength(bs
->file
->bs
);
181 static int replication_get_io_status(BDRVReplicationState
*s
)
184 case BLOCK_REPLICATION_NONE
:
186 case BLOCK_REPLICATION_RUNNING
:
188 case BLOCK_REPLICATION_FAILOVER
:
189 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 0;
190 case BLOCK_REPLICATION_FAILOVER_FAILED
:
191 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 1;
192 case BLOCK_REPLICATION_DONE
:
194 * active commit job completes, and active disk and secondary_disk
195 * is swapped, so we can operate bs->file directly
197 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 0;
203 static int replication_return_value(BDRVReplicationState
*s
, int ret
)
205 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
217 static coroutine_fn
int replication_co_readv(BlockDriverState
*bs
,
219 int remaining_sectors
,
222 BDRVReplicationState
*s
= bs
->opaque
;
225 if (s
->mode
== REPLICATION_MODE_PRIMARY
) {
226 /* We only use it to forward primary write requests */
230 ret
= replication_get_io_status(s
);
235 ret
= bdrv_co_preadv(bs
->file
, sector_num
* BDRV_SECTOR_SIZE
,
236 remaining_sectors
* BDRV_SECTOR_SIZE
, qiov
, 0);
238 return replication_return_value(s
, ret
);
241 static coroutine_fn
int replication_co_writev(BlockDriverState
*bs
,
243 int remaining_sectors
,
247 BDRVReplicationState
*s
= bs
->opaque
;
248 QEMUIOVector hd_qiov
;
249 uint64_t bytes_done
= 0;
250 BdrvChild
*top
= bs
->file
;
251 BdrvChild
*base
= s
->secondary_disk
;
257 ret
= replication_get_io_status(s
);
263 ret
= bdrv_co_pwritev(top
, sector_num
* BDRV_SECTOR_SIZE
,
264 remaining_sectors
* BDRV_SECTOR_SIZE
, qiov
, 0);
265 return replication_return_value(s
, ret
);
269 * Failover failed, only write to active disk if the sectors
270 * have already been allocated in active disk/hidden disk.
272 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
273 while (remaining_sectors
> 0) {
276 ret
= bdrv_is_allocated_above(top
->bs
, base
->bs
,
277 sector_num
* BDRV_SECTOR_SIZE
,
278 remaining_sectors
* BDRV_SECTOR_SIZE
,
284 assert(QEMU_IS_ALIGNED(count
, BDRV_SECTOR_SIZE
));
285 n
= count
>> BDRV_SECTOR_BITS
;
286 qemu_iovec_reset(&hd_qiov
);
287 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, count
);
289 target
= ret
? top
: base
;
290 ret
= bdrv_co_pwritev(target
, sector_num
* BDRV_SECTOR_SIZE
,
291 n
* BDRV_SECTOR_SIZE
, &hd_qiov
, 0);
296 remaining_sectors
-= n
;
302 qemu_iovec_destroy(&hd_qiov
);
307 static bool replication_recurse_is_first_non_filter(BlockDriverState
*bs
,
308 BlockDriverState
*candidate
)
310 return bdrv_recurse_is_first_non_filter(bs
->file
->bs
, candidate
);
313 static void secondary_do_checkpoint(BDRVReplicationState
*s
, Error
**errp
)
315 Error
*local_err
= NULL
;
318 if (!s
->secondary_disk
->bs
->job
) {
319 error_setg(errp
, "Backup job was cancelled unexpectedly");
323 backup_do_checkpoint(s
->secondary_disk
->bs
->job
, &local_err
);
325 error_propagate(errp
, local_err
);
329 if (!s
->active_disk
->bs
->drv
) {
330 error_setg(errp
, "Active disk %s is ejected",
331 s
->active_disk
->bs
->node_name
);
335 ret
= s
->active_disk
->bs
->drv
->bdrv_make_empty(s
->active_disk
->bs
);
337 error_setg(errp
, "Cannot make active disk empty");
341 if (!s
->hidden_disk
->bs
->drv
) {
342 error_setg(errp
, "Hidden disk %s is ejected",
343 s
->hidden_disk
->bs
->node_name
);
347 ret
= s
->hidden_disk
->bs
->drv
->bdrv_make_empty(s
->hidden_disk
->bs
);
349 error_setg(errp
, "Cannot make hidden disk empty");
354 /* This function is supposed to be called twice:
355 * first with writable = true, then with writable = false.
356 * The first call puts s->hidden_disk and s->secondary_disk in
357 * r/w mode, and the second puts them back in their original state.
359 static void reopen_backing_file(BlockDriverState
*bs
, bool writable
,
362 BDRVReplicationState
*s
= bs
->opaque
;
363 BlockReopenQueue
*reopen_queue
= NULL
;
364 Error
*local_err
= NULL
;
367 s
->orig_hidden_read_only
= bdrv_is_read_only(s
->hidden_disk
->bs
);
368 s
->orig_secondary_read_only
= bdrv_is_read_only(s
->secondary_disk
->bs
);
371 bdrv_subtree_drained_begin(s
->hidden_disk
->bs
);
372 bdrv_subtree_drained_begin(s
->secondary_disk
->bs
);
374 if (s
->orig_hidden_read_only
) {
375 QDict
*opts
= qdict_new();
376 qdict_put_bool(opts
, BDRV_OPT_READ_ONLY
, !writable
);
377 reopen_queue
= bdrv_reopen_queue(reopen_queue
, s
->hidden_disk
->bs
,
381 if (s
->orig_secondary_read_only
) {
382 QDict
*opts
= qdict_new();
383 qdict_put_bool(opts
, BDRV_OPT_READ_ONLY
, !writable
);
384 reopen_queue
= bdrv_reopen_queue(reopen_queue
, s
->secondary_disk
->bs
,
389 bdrv_reopen_multiple(reopen_queue
, &local_err
);
390 error_propagate(errp
, local_err
);
393 bdrv_subtree_drained_end(s
->hidden_disk
->bs
);
394 bdrv_subtree_drained_end(s
->secondary_disk
->bs
);
397 static void backup_job_cleanup(BlockDriverState
*bs
)
399 BDRVReplicationState
*s
= bs
->opaque
;
400 BlockDriverState
*top_bs
;
402 top_bs
= bdrv_lookup_bs(s
->top_id
, s
->top_id
, NULL
);
406 bdrv_op_unblock_all(top_bs
, s
->blocker
);
407 error_free(s
->blocker
);
408 reopen_backing_file(bs
, false, NULL
);
411 static void backup_job_completed(void *opaque
, int ret
)
413 BlockDriverState
*bs
= opaque
;
414 BDRVReplicationState
*s
= bs
->opaque
;
416 if (s
->stage
!= BLOCK_REPLICATION_FAILOVER
) {
417 /* The backup job is cancelled unexpectedly */
421 backup_job_cleanup(bs
);
424 static bool check_top_bs(BlockDriverState
*top_bs
, BlockDriverState
*bs
)
428 /* The bs itself is the top_bs */
433 /* Iterate over top_bs's children */
434 QLIST_FOREACH(child
, &top_bs
->children
, next
) {
435 if (child
->bs
== bs
|| check_top_bs(child
->bs
, bs
)) {
443 static void replication_start(ReplicationState
*rs
, ReplicationMode mode
,
446 BlockDriverState
*bs
= rs
->opaque
;
447 BDRVReplicationState
*s
;
448 BlockDriverState
*top_bs
;
449 int64_t active_length
, hidden_length
, disk_length
;
450 AioContext
*aio_context
;
451 Error
*local_err
= NULL
;
454 aio_context
= bdrv_get_aio_context(bs
);
455 aio_context_acquire(aio_context
);
458 if (s
->stage
!= BLOCK_REPLICATION_NONE
) {
459 error_setg(errp
, "Block replication is running or done");
460 aio_context_release(aio_context
);
464 if (s
->mode
!= mode
) {
465 error_setg(errp
, "The parameter mode's value is invalid, needs %d,"
466 " but got %d", s
->mode
, mode
);
467 aio_context_release(aio_context
);
472 case REPLICATION_MODE_PRIMARY
:
474 case REPLICATION_MODE_SECONDARY
:
475 s
->active_disk
= bs
->file
;
476 if (!s
->active_disk
|| !s
->active_disk
->bs
||
477 !s
->active_disk
->bs
->backing
) {
478 error_setg(errp
, "Active disk doesn't have backing file");
479 aio_context_release(aio_context
);
483 s
->hidden_disk
= s
->active_disk
->bs
->backing
;
484 if (!s
->hidden_disk
->bs
|| !s
->hidden_disk
->bs
->backing
) {
485 error_setg(errp
, "Hidden disk doesn't have backing file");
486 aio_context_release(aio_context
);
490 s
->secondary_disk
= s
->hidden_disk
->bs
->backing
;
491 if (!s
->secondary_disk
->bs
|| !bdrv_has_blk(s
->secondary_disk
->bs
)) {
492 error_setg(errp
, "The secondary disk doesn't have block backend");
493 aio_context_release(aio_context
);
497 /* verify the length */
498 active_length
= bdrv_getlength(s
->active_disk
->bs
);
499 hidden_length
= bdrv_getlength(s
->hidden_disk
->bs
);
500 disk_length
= bdrv_getlength(s
->secondary_disk
->bs
);
501 if (active_length
< 0 || hidden_length
< 0 || disk_length
< 0 ||
502 active_length
!= hidden_length
|| hidden_length
!= disk_length
) {
503 error_setg(errp
, "Active disk, hidden disk, secondary disk's length"
504 " are not the same");
505 aio_context_release(aio_context
);
509 /* Must be true, or the bdrv_getlength() calls would have failed */
510 assert(s
->active_disk
->bs
->drv
&& s
->hidden_disk
->bs
->drv
);
512 if (!s
->active_disk
->bs
->drv
->bdrv_make_empty
||
513 !s
->hidden_disk
->bs
->drv
->bdrv_make_empty
) {
515 "Active disk or hidden disk doesn't support make_empty");
516 aio_context_release(aio_context
);
520 /* reopen the backing file in r/w mode */
521 reopen_backing_file(bs
, true, &local_err
);
523 error_propagate(errp
, local_err
);
524 aio_context_release(aio_context
);
528 /* start backup job now */
529 error_setg(&s
->blocker
,
530 "Block device is in use by internal backup job");
532 top_bs
= bdrv_lookup_bs(s
->top_id
, s
->top_id
, NULL
);
533 if (!top_bs
|| !bdrv_is_root_node(top_bs
) ||
534 !check_top_bs(top_bs
, bs
)) {
535 error_setg(errp
, "No top_bs or it is invalid");
536 reopen_backing_file(bs
, false, NULL
);
537 aio_context_release(aio_context
);
540 bdrv_op_block_all(top_bs
, s
->blocker
);
541 bdrv_op_unblock(top_bs
, BLOCK_OP_TYPE_DATAPLANE
, s
->blocker
);
543 job
= backup_job_create(NULL
, s
->secondary_disk
->bs
, s
->hidden_disk
->bs
,
544 0, MIRROR_SYNC_MODE_NONE
, NULL
, false,
545 BLOCKDEV_ON_ERROR_REPORT
,
546 BLOCKDEV_ON_ERROR_REPORT
, JOB_INTERNAL
,
547 backup_job_completed
, bs
, NULL
, &local_err
);
549 error_propagate(errp
, local_err
);
550 backup_job_cleanup(bs
);
551 aio_context_release(aio_context
);
554 job_start(&job
->job
);
557 aio_context_release(aio_context
);
561 s
->stage
= BLOCK_REPLICATION_RUNNING
;
563 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
564 secondary_do_checkpoint(s
, errp
);
568 aio_context_release(aio_context
);
571 static void replication_do_checkpoint(ReplicationState
*rs
, Error
**errp
)
573 BlockDriverState
*bs
= rs
->opaque
;
574 BDRVReplicationState
*s
;
575 AioContext
*aio_context
;
577 aio_context
= bdrv_get_aio_context(bs
);
578 aio_context_acquire(aio_context
);
581 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
582 secondary_do_checkpoint(s
, errp
);
584 aio_context_release(aio_context
);
587 static void replication_get_error(ReplicationState
*rs
, Error
**errp
)
589 BlockDriverState
*bs
= rs
->opaque
;
590 BDRVReplicationState
*s
;
591 AioContext
*aio_context
;
593 aio_context
= bdrv_get_aio_context(bs
);
594 aio_context_acquire(aio_context
);
597 if (s
->stage
!= BLOCK_REPLICATION_RUNNING
) {
598 error_setg(errp
, "Block replication is not running");
599 aio_context_release(aio_context
);
604 error_setg(errp
, "I/O error occurred");
605 aio_context_release(aio_context
);
608 aio_context_release(aio_context
);
611 static void replication_done(void *opaque
, int ret
)
613 BlockDriverState
*bs
= opaque
;
614 BDRVReplicationState
*s
= bs
->opaque
;
617 s
->stage
= BLOCK_REPLICATION_DONE
;
619 s
->active_disk
= NULL
;
620 s
->secondary_disk
= NULL
;
621 s
->hidden_disk
= NULL
;
624 s
->stage
= BLOCK_REPLICATION_FAILOVER_FAILED
;
629 static void replication_stop(ReplicationState
*rs
, bool failover
, Error
**errp
)
631 BlockDriverState
*bs
= rs
->opaque
;
632 BDRVReplicationState
*s
;
633 AioContext
*aio_context
;
635 aio_context
= bdrv_get_aio_context(bs
);
636 aio_context_acquire(aio_context
);
639 if (s
->stage
!= BLOCK_REPLICATION_RUNNING
) {
640 error_setg(errp
, "Block replication is not running");
641 aio_context_release(aio_context
);
646 case REPLICATION_MODE_PRIMARY
:
647 s
->stage
= BLOCK_REPLICATION_DONE
;
650 case REPLICATION_MODE_SECONDARY
:
652 * This BDS will be closed, and the job should be completed
653 * before the BDS is closed, because we will access hidden
654 * disk, secondary disk in backup_job_completed().
656 if (s
->secondary_disk
->bs
->job
) {
657 job_cancel_sync(&s
->secondary_disk
->bs
->job
->job
);
661 secondary_do_checkpoint(s
, errp
);
662 s
->stage
= BLOCK_REPLICATION_DONE
;
663 aio_context_release(aio_context
);
667 s
->stage
= BLOCK_REPLICATION_FAILOVER
;
668 commit_active_start(NULL
, s
->active_disk
->bs
, s
->secondary_disk
->bs
,
669 JOB_INTERNAL
, 0, BLOCKDEV_ON_ERROR_REPORT
,
670 NULL
, replication_done
, bs
, true, errp
);
673 aio_context_release(aio_context
);
676 aio_context_release(aio_context
);
679 static const char *const replication_strong_runtime_opts
[] = {
686 static BlockDriver bdrv_replication
= {
687 .format_name
= "replication",
688 .instance_size
= sizeof(BDRVReplicationState
),
690 .bdrv_open
= replication_open
,
691 .bdrv_close
= replication_close
,
692 .bdrv_child_perm
= replication_child_perm
,
694 .bdrv_getlength
= replication_getlength
,
695 .bdrv_co_readv
= replication_co_readv
,
696 .bdrv_co_writev
= replication_co_writev
,
699 .bdrv_recurse_is_first_non_filter
= replication_recurse_is_first_non_filter
,
701 .has_variable_length
= true,
702 .strong_runtime_opts
= replication_strong_runtime_opts
,
705 static void bdrv_replication_init(void)
707 bdrv_register(&bdrv_replication
);
710 block_init(bdrv_replication_init
);