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/option.h"
17 #include "block/nbd.h"
18 #include "block/blockjob.h"
19 #include "block/block_int.h"
20 #include "block/block_backup.h"
21 #include "sysemu/block-backend.h"
22 #include "qapi/error.h"
23 #include "replication.h"
26 BLOCK_REPLICATION_NONE
, /* block replication is not started */
27 BLOCK_REPLICATION_RUNNING
, /* block replication is running */
28 BLOCK_REPLICATION_FAILOVER
, /* failover is running in background */
29 BLOCK_REPLICATION_FAILOVER_FAILED
, /* failover failed */
30 BLOCK_REPLICATION_DONE
, /* block replication is done */
33 typedef struct BDRVReplicationState
{
35 ReplicationStage stage
;
36 BdrvChild
*active_disk
;
37 BdrvChild
*hidden_disk
;
38 BdrvChild
*secondary_disk
;
42 int orig_hidden_flags
;
43 int orig_secondary_flags
;
45 } BDRVReplicationState
;
47 static void replication_start(ReplicationState
*rs
, ReplicationMode mode
,
49 static void replication_do_checkpoint(ReplicationState
*rs
, Error
**errp
);
50 static void replication_get_error(ReplicationState
*rs
, Error
**errp
);
51 static void replication_stop(ReplicationState
*rs
, bool failover
,
54 #define REPLICATION_MODE "mode"
55 #define REPLICATION_TOP_ID "top-id"
56 static QemuOptsList replication_runtime_opts
= {
57 .name
= "replication",
58 .head
= QTAILQ_HEAD_INITIALIZER(replication_runtime_opts
.head
),
61 .name
= REPLICATION_MODE
,
62 .type
= QEMU_OPT_STRING
,
65 .name
= REPLICATION_TOP_ID
,
66 .type
= QEMU_OPT_STRING
,
72 static ReplicationOps replication_ops
= {
73 .start
= replication_start
,
74 .checkpoint
= replication_do_checkpoint
,
75 .get_error
= replication_get_error
,
76 .stop
= replication_stop
,
79 static int replication_open(BlockDriverState
*bs
, QDict
*options
,
80 int flags
, Error
**errp
)
83 BDRVReplicationState
*s
= bs
->opaque
;
84 Error
*local_err
= NULL
;
85 QemuOpts
*opts
= NULL
;
89 bs
->file
= bdrv_open_child(NULL
, options
, "file", bs
, &child_file
,
96 opts
= qemu_opts_create(&replication_runtime_opts
, NULL
, 0, &error_abort
);
97 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
102 mode
= qemu_opt_get(opts
, REPLICATION_MODE
);
104 error_setg(&local_err
, "Missing the option mode");
108 if (!strcmp(mode
, "primary")) {
109 s
->mode
= REPLICATION_MODE_PRIMARY
;
110 top_id
= qemu_opt_get(opts
, REPLICATION_TOP_ID
);
112 error_setg(&local_err
, "The primary side does not support option top-id");
115 } else if (!strcmp(mode
, "secondary")) {
116 s
->mode
= REPLICATION_MODE_SECONDARY
;
117 top_id
= qemu_opt_get(opts
, REPLICATION_TOP_ID
);
118 s
->top_id
= g_strdup(top_id
);
120 error_setg(&local_err
, "Missing the option top-id");
124 error_setg(&local_err
,
125 "The option mode's value should be primary or secondary");
129 s
->rs
= replication_new(bs
, &replication_ops
);
135 error_propagate(errp
, local_err
);
140 static void replication_close(BlockDriverState
*bs
)
142 BDRVReplicationState
*s
= bs
->opaque
;
144 if (s
->stage
== BLOCK_REPLICATION_RUNNING
) {
145 replication_stop(s
->rs
, false, NULL
);
147 if (s
->stage
== BLOCK_REPLICATION_FAILOVER
) {
148 job_cancel_sync(&s
->active_disk
->bs
->job
->job
);
151 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
155 replication_remove(s
->rs
);
158 static void replication_child_perm(BlockDriverState
*bs
, BdrvChild
*c
,
159 const BdrvChildRole
*role
,
160 BlockReopenQueue
*reopen_queue
,
161 uint64_t perm
, uint64_t shared
,
162 uint64_t *nperm
, uint64_t *nshared
)
164 *nperm
= BLK_PERM_CONSISTENT_READ
;
165 if ((bs
->open_flags
& (BDRV_O_INACTIVE
| BDRV_O_RDWR
)) == BDRV_O_RDWR
) {
166 *nperm
|= BLK_PERM_WRITE
;
168 *nshared
= BLK_PERM_CONSISTENT_READ \
170 | BLK_PERM_WRITE_UNCHANGED
;
174 static int64_t replication_getlength(BlockDriverState
*bs
)
176 return bdrv_getlength(bs
->file
->bs
);
179 static int replication_get_io_status(BDRVReplicationState
*s
)
182 case BLOCK_REPLICATION_NONE
:
184 case BLOCK_REPLICATION_RUNNING
:
186 case BLOCK_REPLICATION_FAILOVER
:
187 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 0;
188 case BLOCK_REPLICATION_FAILOVER_FAILED
:
189 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 1;
190 case BLOCK_REPLICATION_DONE
:
192 * active commit job completes, and active disk and secondary_disk
193 * is swapped, so we can operate bs->file directly
195 return s
->mode
== REPLICATION_MODE_PRIMARY
? -EIO
: 0;
201 static int replication_return_value(BDRVReplicationState
*s
, int ret
)
203 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
215 static coroutine_fn
int replication_co_readv(BlockDriverState
*bs
,
217 int remaining_sectors
,
220 BDRVReplicationState
*s
= bs
->opaque
;
221 BdrvChild
*child
= s
->secondary_disk
;
222 BlockJob
*job
= NULL
;
226 if (s
->mode
== REPLICATION_MODE_PRIMARY
) {
227 /* We only use it to forward primary write requests */
231 ret
= replication_get_io_status(s
);
236 if (child
&& child
->bs
) {
237 job
= child
->bs
->job
;
241 uint64_t remaining_bytes
= remaining_sectors
* BDRV_SECTOR_SIZE
;
243 backup_wait_for_overlapping_requests(child
->bs
->job
,
244 sector_num
* BDRV_SECTOR_SIZE
,
246 backup_cow_request_begin(&req
, child
->bs
->job
,
247 sector_num
* BDRV_SECTOR_SIZE
,
249 ret
= bdrv_co_readv(bs
->file
, sector_num
, remaining_sectors
,
251 backup_cow_request_end(&req
);
255 ret
= bdrv_co_readv(bs
->file
, sector_num
, remaining_sectors
, qiov
);
257 return replication_return_value(s
, ret
);
260 static coroutine_fn
int replication_co_writev(BlockDriverState
*bs
,
262 int remaining_sectors
,
266 BDRVReplicationState
*s
= bs
->opaque
;
267 QEMUIOVector hd_qiov
;
268 uint64_t bytes_done
= 0;
269 BdrvChild
*top
= bs
->file
;
270 BdrvChild
*base
= s
->secondary_disk
;
276 ret
= replication_get_io_status(s
);
282 ret
= bdrv_co_writev(top
, sector_num
,
283 remaining_sectors
, qiov
);
284 return replication_return_value(s
, ret
);
288 * Failover failed, only write to active disk if the sectors
289 * have already been allocated in active disk/hidden disk.
291 qemu_iovec_init(&hd_qiov
, qiov
->niov
);
292 while (remaining_sectors
> 0) {
295 ret
= bdrv_is_allocated_above(top
->bs
, base
->bs
,
296 sector_num
* BDRV_SECTOR_SIZE
,
297 remaining_sectors
* BDRV_SECTOR_SIZE
,
303 assert(QEMU_IS_ALIGNED(count
, BDRV_SECTOR_SIZE
));
304 n
= count
>> BDRV_SECTOR_BITS
;
305 qemu_iovec_reset(&hd_qiov
);
306 qemu_iovec_concat(&hd_qiov
, qiov
, bytes_done
, count
);
308 target
= ret
? top
: base
;
309 ret
= bdrv_co_writev(target
, sector_num
, n
, &hd_qiov
);
314 remaining_sectors
-= n
;
320 qemu_iovec_destroy(&hd_qiov
);
325 static bool replication_recurse_is_first_non_filter(BlockDriverState
*bs
,
326 BlockDriverState
*candidate
)
328 return bdrv_recurse_is_first_non_filter(bs
->file
->bs
, candidate
);
331 static void secondary_do_checkpoint(BDRVReplicationState
*s
, Error
**errp
)
333 Error
*local_err
= NULL
;
336 if (!s
->secondary_disk
->bs
->job
) {
337 error_setg(errp
, "Backup job was cancelled unexpectedly");
341 backup_do_checkpoint(s
->secondary_disk
->bs
->job
, &local_err
);
343 error_propagate(errp
, local_err
);
347 if (!s
->active_disk
->bs
->drv
) {
348 error_setg(errp
, "Active disk %s is ejected",
349 s
->active_disk
->bs
->node_name
);
353 ret
= s
->active_disk
->bs
->drv
->bdrv_make_empty(s
->active_disk
->bs
);
355 error_setg(errp
, "Cannot make active disk empty");
359 if (!s
->hidden_disk
->bs
->drv
) {
360 error_setg(errp
, "Hidden disk %s is ejected",
361 s
->hidden_disk
->bs
->node_name
);
365 ret
= s
->hidden_disk
->bs
->drv
->bdrv_make_empty(s
->hidden_disk
->bs
);
367 error_setg(errp
, "Cannot make hidden disk empty");
372 static void reopen_backing_file(BlockDriverState
*bs
, bool writable
,
375 BDRVReplicationState
*s
= bs
->opaque
;
376 BlockReopenQueue
*reopen_queue
= NULL
;
377 int orig_hidden_flags
, orig_secondary_flags
;
378 int new_hidden_flags
, new_secondary_flags
;
379 Error
*local_err
= NULL
;
382 orig_hidden_flags
= s
->orig_hidden_flags
=
383 bdrv_get_flags(s
->hidden_disk
->bs
);
384 new_hidden_flags
= (orig_hidden_flags
| BDRV_O_RDWR
) &
386 orig_secondary_flags
= s
->orig_secondary_flags
=
387 bdrv_get_flags(s
->secondary_disk
->bs
);
388 new_secondary_flags
= (orig_secondary_flags
| BDRV_O_RDWR
) &
391 orig_hidden_flags
= (s
->orig_hidden_flags
| BDRV_O_RDWR
) &
393 new_hidden_flags
= s
->orig_hidden_flags
;
394 orig_secondary_flags
= (s
->orig_secondary_flags
| BDRV_O_RDWR
) &
396 new_secondary_flags
= s
->orig_secondary_flags
;
399 bdrv_subtree_drained_begin(s
->hidden_disk
->bs
);
400 bdrv_subtree_drained_begin(s
->secondary_disk
->bs
);
402 if (orig_hidden_flags
!= new_hidden_flags
) {
403 reopen_queue
= bdrv_reopen_queue(reopen_queue
, s
->hidden_disk
->bs
, NULL
,
407 if (!(orig_secondary_flags
& BDRV_O_RDWR
)) {
408 reopen_queue
= bdrv_reopen_queue(reopen_queue
, s
->secondary_disk
->bs
,
409 NULL
, new_secondary_flags
);
413 bdrv_reopen_multiple(bdrv_get_aio_context(bs
),
414 reopen_queue
, &local_err
);
415 error_propagate(errp
, local_err
);
418 bdrv_subtree_drained_end(s
->hidden_disk
->bs
);
419 bdrv_subtree_drained_end(s
->secondary_disk
->bs
);
422 static void backup_job_cleanup(BlockDriverState
*bs
)
424 BDRVReplicationState
*s
= bs
->opaque
;
425 BlockDriverState
*top_bs
;
427 top_bs
= bdrv_lookup_bs(s
->top_id
, s
->top_id
, NULL
);
431 bdrv_op_unblock_all(top_bs
, s
->blocker
);
432 error_free(s
->blocker
);
433 reopen_backing_file(bs
, false, NULL
);
436 static void backup_job_completed(void *opaque
, int ret
)
438 BlockDriverState
*bs
= opaque
;
439 BDRVReplicationState
*s
= bs
->opaque
;
441 if (s
->stage
!= BLOCK_REPLICATION_FAILOVER
) {
442 /* The backup job is cancelled unexpectedly */
446 backup_job_cleanup(bs
);
449 static bool check_top_bs(BlockDriverState
*top_bs
, BlockDriverState
*bs
)
453 /* The bs itself is the top_bs */
458 /* Iterate over top_bs's children */
459 QLIST_FOREACH(child
, &top_bs
->children
, next
) {
460 if (child
->bs
== bs
|| check_top_bs(child
->bs
, bs
)) {
468 static void replication_start(ReplicationState
*rs
, ReplicationMode mode
,
471 BlockDriverState
*bs
= rs
->opaque
;
472 BDRVReplicationState
*s
;
473 BlockDriverState
*top_bs
;
474 int64_t active_length
, hidden_length
, disk_length
;
475 AioContext
*aio_context
;
476 Error
*local_err
= NULL
;
479 aio_context
= bdrv_get_aio_context(bs
);
480 aio_context_acquire(aio_context
);
483 if (s
->stage
!= BLOCK_REPLICATION_NONE
) {
484 error_setg(errp
, "Block replication is running or done");
485 aio_context_release(aio_context
);
489 if (s
->mode
!= mode
) {
490 error_setg(errp
, "The parameter mode's value is invalid, needs %d,"
491 " but got %d", s
->mode
, mode
);
492 aio_context_release(aio_context
);
497 case REPLICATION_MODE_PRIMARY
:
499 case REPLICATION_MODE_SECONDARY
:
500 s
->active_disk
= bs
->file
;
501 if (!s
->active_disk
|| !s
->active_disk
->bs
||
502 !s
->active_disk
->bs
->backing
) {
503 error_setg(errp
, "Active disk doesn't have backing file");
504 aio_context_release(aio_context
);
508 s
->hidden_disk
= s
->active_disk
->bs
->backing
;
509 if (!s
->hidden_disk
->bs
|| !s
->hidden_disk
->bs
->backing
) {
510 error_setg(errp
, "Hidden disk doesn't have backing file");
511 aio_context_release(aio_context
);
515 s
->secondary_disk
= s
->hidden_disk
->bs
->backing
;
516 if (!s
->secondary_disk
->bs
|| !bdrv_has_blk(s
->secondary_disk
->bs
)) {
517 error_setg(errp
, "The secondary disk doesn't have block backend");
518 aio_context_release(aio_context
);
522 /* verify the length */
523 active_length
= bdrv_getlength(s
->active_disk
->bs
);
524 hidden_length
= bdrv_getlength(s
->hidden_disk
->bs
);
525 disk_length
= bdrv_getlength(s
->secondary_disk
->bs
);
526 if (active_length
< 0 || hidden_length
< 0 || disk_length
< 0 ||
527 active_length
!= hidden_length
|| hidden_length
!= disk_length
) {
528 error_setg(errp
, "Active disk, hidden disk, secondary disk's length"
529 " are not the same");
530 aio_context_release(aio_context
);
534 /* Must be true, or the bdrv_getlength() calls would have failed */
535 assert(s
->active_disk
->bs
->drv
&& s
->hidden_disk
->bs
->drv
);
537 if (!s
->active_disk
->bs
->drv
->bdrv_make_empty
||
538 !s
->hidden_disk
->bs
->drv
->bdrv_make_empty
) {
540 "Active disk or hidden disk doesn't support make_empty");
541 aio_context_release(aio_context
);
545 /* reopen the backing file in r/w mode */
546 reopen_backing_file(bs
, true, &local_err
);
548 error_propagate(errp
, local_err
);
549 aio_context_release(aio_context
);
553 /* start backup job now */
554 error_setg(&s
->blocker
,
555 "Block device is in use by internal backup job");
557 top_bs
= bdrv_lookup_bs(s
->top_id
, s
->top_id
, NULL
);
558 if (!top_bs
|| !bdrv_is_root_node(top_bs
) ||
559 !check_top_bs(top_bs
, bs
)) {
560 error_setg(errp
, "No top_bs or it is invalid");
561 reopen_backing_file(bs
, false, NULL
);
562 aio_context_release(aio_context
);
565 bdrv_op_block_all(top_bs
, s
->blocker
);
566 bdrv_op_unblock(top_bs
, BLOCK_OP_TYPE_DATAPLANE
, s
->blocker
);
568 job
= backup_job_create(NULL
, s
->secondary_disk
->bs
, s
->hidden_disk
->bs
,
569 0, MIRROR_SYNC_MODE_NONE
, NULL
, false,
570 BLOCKDEV_ON_ERROR_REPORT
,
571 BLOCKDEV_ON_ERROR_REPORT
, JOB_INTERNAL
,
572 backup_job_completed
, bs
, NULL
, &local_err
);
574 error_propagate(errp
, local_err
);
575 backup_job_cleanup(bs
);
576 aio_context_release(aio_context
);
579 job_start(&job
->job
);
582 aio_context_release(aio_context
);
586 s
->stage
= BLOCK_REPLICATION_RUNNING
;
588 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
589 secondary_do_checkpoint(s
, errp
);
593 aio_context_release(aio_context
);
596 static void replication_do_checkpoint(ReplicationState
*rs
, Error
**errp
)
598 BlockDriverState
*bs
= rs
->opaque
;
599 BDRVReplicationState
*s
;
600 AioContext
*aio_context
;
602 aio_context
= bdrv_get_aio_context(bs
);
603 aio_context_acquire(aio_context
);
606 if (s
->mode
== REPLICATION_MODE_SECONDARY
) {
607 secondary_do_checkpoint(s
, errp
);
609 aio_context_release(aio_context
);
612 static void replication_get_error(ReplicationState
*rs
, Error
**errp
)
614 BlockDriverState
*bs
= rs
->opaque
;
615 BDRVReplicationState
*s
;
616 AioContext
*aio_context
;
618 aio_context
= bdrv_get_aio_context(bs
);
619 aio_context_acquire(aio_context
);
622 if (s
->stage
!= BLOCK_REPLICATION_RUNNING
) {
623 error_setg(errp
, "Block replication is not running");
624 aio_context_release(aio_context
);
629 error_setg(errp
, "I/O error occurred");
630 aio_context_release(aio_context
);
633 aio_context_release(aio_context
);
636 static void replication_done(void *opaque
, int ret
)
638 BlockDriverState
*bs
= opaque
;
639 BDRVReplicationState
*s
= bs
->opaque
;
642 s
->stage
= BLOCK_REPLICATION_DONE
;
644 /* refresh top bs's filename */
645 bdrv_refresh_filename(bs
);
646 s
->active_disk
= NULL
;
647 s
->secondary_disk
= NULL
;
648 s
->hidden_disk
= NULL
;
651 s
->stage
= BLOCK_REPLICATION_FAILOVER_FAILED
;
656 static void replication_stop(ReplicationState
*rs
, bool failover
, Error
**errp
)
658 BlockDriverState
*bs
= rs
->opaque
;
659 BDRVReplicationState
*s
;
660 AioContext
*aio_context
;
662 aio_context
= bdrv_get_aio_context(bs
);
663 aio_context_acquire(aio_context
);
666 if (s
->stage
!= BLOCK_REPLICATION_RUNNING
) {
667 error_setg(errp
, "Block replication is not running");
668 aio_context_release(aio_context
);
673 case REPLICATION_MODE_PRIMARY
:
674 s
->stage
= BLOCK_REPLICATION_DONE
;
677 case REPLICATION_MODE_SECONDARY
:
679 * This BDS will be closed, and the job should be completed
680 * before the BDS is closed, because we will access hidden
681 * disk, secondary disk in backup_job_completed().
683 if (s
->secondary_disk
->bs
->job
) {
684 job_cancel_sync(&s
->secondary_disk
->bs
->job
->job
);
688 secondary_do_checkpoint(s
, errp
);
689 s
->stage
= BLOCK_REPLICATION_DONE
;
690 aio_context_release(aio_context
);
694 s
->stage
= BLOCK_REPLICATION_FAILOVER
;
695 commit_active_start(NULL
, s
->active_disk
->bs
, s
->secondary_disk
->bs
,
696 JOB_INTERNAL
, 0, BLOCKDEV_ON_ERROR_REPORT
,
697 NULL
, replication_done
, bs
, true, errp
);
700 aio_context_release(aio_context
);
703 aio_context_release(aio_context
);
706 BlockDriver bdrv_replication
= {
707 .format_name
= "replication",
708 .instance_size
= sizeof(BDRVReplicationState
),
710 .bdrv_open
= replication_open
,
711 .bdrv_close
= replication_close
,
712 .bdrv_child_perm
= replication_child_perm
,
714 .bdrv_getlength
= replication_getlength
,
715 .bdrv_co_readv
= replication_co_readv
,
716 .bdrv_co_writev
= replication_co_writev
,
719 .bdrv_recurse_is_first_non_filter
= replication_recurse_is_first_non_filter
,
721 .has_variable_length
= true,
724 static void bdrv_replication_init(void)
726 bdrv_register(&bdrv_replication
);
729 block_init(bdrv_replication_init
);