1 /* 2 * Replication Block filter 3 * 4 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD. 5 * Copyright (c) 2016 Intel Corporation 6 * Copyright (c) 2016 FUJITSU LIMITED 7 * 8 * Author: 9 * Wen Congyang <wency@cn.fujitsu.com> 10 * 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. 13 */ 14 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" 26 27 typedef enum { 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 */ 33 } ReplicationStage; 34 35 typedef struct BDRVReplicationState { 36 ReplicationMode mode; 37 ReplicationStage stage; 38 BlockJob *commit_job; 39 BdrvChild *hidden_disk; 40 BdrvChild *secondary_disk; 41 BlockJob *backup_job; 42 char *top_id; 43 ReplicationState *rs; 44 Error *blocker; 45 bool orig_hidden_read_only; 46 bool orig_secondary_read_only; 47 int error; 48 } BDRVReplicationState; 49 50 static void replication_start(ReplicationState *rs, ReplicationMode mode, 51 Error **errp); 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, 55 Error **errp); 56 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), 62 .desc = { 63 { 64 .name = REPLICATION_MODE, 65 .type = QEMU_OPT_STRING, 66 }, 67 { 68 .name = REPLICATION_TOP_ID, 69 .type = QEMU_OPT_STRING, 70 }, 71 { /* end of list */ } 72 }, 73 }; 74 75 static ReplicationOps replication_ops = { 76 .start = replication_start, 77 .checkpoint = replication_do_checkpoint, 78 .get_error = replication_get_error, 79 .stop = replication_stop, 80 }; 81 82 static int replication_open(BlockDriverState *bs, QDict *options, 83 int flags, Error **errp) 84 { 85 int ret; 86 BDRVReplicationState *s = bs->opaque; 87 QemuOpts *opts = NULL; 88 const char *mode; 89 const char *top_id; 90 91 ret = bdrv_open_file_child(NULL, options, "file", bs, errp); 92 if (ret < 0) { 93 return ret; 94 } 95 96 ret = -EINVAL; 97 opts = qemu_opts_create(&replication_runtime_opts, NULL, 0, &error_abort); 98 if (!qemu_opts_absorb_qdict(opts, options, errp)) { 99 goto fail; 100 } 101 102 mode = qemu_opt_get(opts, REPLICATION_MODE); 103 if (!mode) { 104 error_setg(errp, "Missing the option mode"); 105 goto fail; 106 } 107 108 if (!strcmp(mode, "primary")) { 109 s->mode = REPLICATION_MODE_PRIMARY; 110 top_id = qemu_opt_get(opts, REPLICATION_TOP_ID); 111 if (top_id) { 112 error_setg(errp, 113 "The primary side does not support option top-id"); 114 goto fail; 115 } 116 } else if (!strcmp(mode, "secondary")) { 117 s->mode = REPLICATION_MODE_SECONDARY; 118 top_id = qemu_opt_get(opts, REPLICATION_TOP_ID); 119 s->top_id = g_strdup(top_id); 120 if (!s->top_id) { 121 error_setg(errp, "Missing the option top-id"); 122 goto fail; 123 } 124 } else { 125 error_setg(errp, 126 "The option mode's value should be primary or secondary"); 127 goto fail; 128 } 129 130 s->rs = replication_new(bs, &replication_ops); 131 132 ret = 0; 133 134 fail: 135 qemu_opts_del(opts); 136 return ret; 137 } 138 139 static void replication_close(BlockDriverState *bs) 140 { 141 BDRVReplicationState *s = bs->opaque; 142 Job *commit_job; 143 GLOBAL_STATE_CODE(); 144 145 if (s->stage == BLOCK_REPLICATION_RUNNING) { 146 replication_stop(s->rs, false, NULL); 147 } 148 if (s->stage == BLOCK_REPLICATION_FAILOVER) { 149 commit_job = &s->commit_job->job; 150 assert(commit_job->aio_context == qemu_get_current_aio_context()); 151 job_cancel_sync(commit_job, false); 152 } 153 154 if (s->mode == REPLICATION_MODE_SECONDARY) { 155 g_free(s->top_id); 156 } 157 158 replication_remove(s->rs); 159 } 160 161 static void replication_child_perm(BlockDriverState *bs, BdrvChild *c, 162 BdrvChildRole role, 163 BlockReopenQueue *reopen_queue, 164 uint64_t perm, uint64_t shared, 165 uint64_t *nperm, uint64_t *nshared) 166 { 167 if (role & BDRV_CHILD_PRIMARY) { 168 *nperm = BLK_PERM_CONSISTENT_READ; 169 } else { 170 *nperm = 0; 171 } 172 173 if ((bs->open_flags & (BDRV_O_INACTIVE | BDRV_O_RDWR)) == BDRV_O_RDWR) { 174 *nperm |= BLK_PERM_WRITE; 175 } 176 *nshared = BLK_PERM_CONSISTENT_READ 177 | BLK_PERM_WRITE 178 | BLK_PERM_WRITE_UNCHANGED; 179 return; 180 } 181 182 static int64_t replication_getlength(BlockDriverState *bs) 183 { 184 return bdrv_getlength(bs->file->bs); 185 } 186 187 static int replication_get_io_status(BDRVReplicationState *s) 188 { 189 switch (s->stage) { 190 case BLOCK_REPLICATION_NONE: 191 return -EIO; 192 case BLOCK_REPLICATION_RUNNING: 193 return 0; 194 case BLOCK_REPLICATION_FAILOVER: 195 return s->mode == REPLICATION_MODE_PRIMARY ? -EIO : 0; 196 case BLOCK_REPLICATION_FAILOVER_FAILED: 197 return s->mode == REPLICATION_MODE_PRIMARY ? -EIO : 1; 198 case BLOCK_REPLICATION_DONE: 199 /* 200 * active commit job completes, and active disk and secondary_disk 201 * is swapped, so we can operate bs->file directly 202 */ 203 return s->mode == REPLICATION_MODE_PRIMARY ? -EIO : 0; 204 default: 205 abort(); 206 } 207 } 208 209 static int replication_return_value(BDRVReplicationState *s, int ret) 210 { 211 if (s->mode == REPLICATION_MODE_SECONDARY) { 212 return ret; 213 } 214 215 if (ret < 0) { 216 s->error = ret; 217 ret = 0; 218 } 219 220 return ret; 221 } 222 223 static coroutine_fn int replication_co_readv(BlockDriverState *bs, 224 int64_t sector_num, 225 int remaining_sectors, 226 QEMUIOVector *qiov) 227 { 228 BDRVReplicationState *s = bs->opaque; 229 int ret; 230 231 if (s->mode == REPLICATION_MODE_PRIMARY) { 232 /* We only use it to forward primary write requests */ 233 return -EIO; 234 } 235 236 ret = replication_get_io_status(s); 237 if (ret < 0) { 238 return ret; 239 } 240 241 ret = bdrv_co_preadv(bs->file, sector_num * BDRV_SECTOR_SIZE, 242 remaining_sectors * BDRV_SECTOR_SIZE, qiov, 0); 243 244 return replication_return_value(s, ret); 245 } 246 247 static coroutine_fn int replication_co_writev(BlockDriverState *bs, 248 int64_t sector_num, 249 int remaining_sectors, 250 QEMUIOVector *qiov, 251 int flags) 252 { 253 BDRVReplicationState *s = bs->opaque; 254 QEMUIOVector hd_qiov; 255 uint64_t bytes_done = 0; 256 BdrvChild *top = bs->file; 257 BdrvChild *base = s->secondary_disk; 258 BdrvChild *target; 259 int ret; 260 int64_t n; 261 262 ret = replication_get_io_status(s); 263 if (ret < 0) { 264 goto out; 265 } 266 267 if (ret == 0) { 268 ret = bdrv_co_pwritev(top, sector_num * BDRV_SECTOR_SIZE, 269 remaining_sectors * BDRV_SECTOR_SIZE, qiov, 0); 270 return replication_return_value(s, ret); 271 } 272 273 /* 274 * Failover failed, only write to active disk if the sectors 275 * have already been allocated in active disk/hidden disk. 276 */ 277 qemu_iovec_init(&hd_qiov, qiov->niov); 278 while (remaining_sectors > 0) { 279 int64_t count; 280 281 ret = bdrv_is_allocated_above(top->bs, base->bs, false, 282 sector_num * BDRV_SECTOR_SIZE, 283 remaining_sectors * BDRV_SECTOR_SIZE, 284 &count); 285 if (ret < 0) { 286 goto out1; 287 } 288 289 assert(QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)); 290 n = count >> BDRV_SECTOR_BITS; 291 qemu_iovec_reset(&hd_qiov); 292 qemu_iovec_concat(&hd_qiov, qiov, bytes_done, count); 293 294 target = ret ? top : base; 295 ret = bdrv_co_pwritev(target, sector_num * BDRV_SECTOR_SIZE, 296 n * BDRV_SECTOR_SIZE, &hd_qiov, 0); 297 if (ret < 0) { 298 goto out1; 299 } 300 301 remaining_sectors -= n; 302 sector_num += n; 303 bytes_done += count; 304 } 305 306 out1: 307 qemu_iovec_destroy(&hd_qiov); 308 out: 309 return ret; 310 } 311 312 static void secondary_do_checkpoint(BlockDriverState *bs, Error **errp) 313 { 314 BDRVReplicationState *s = bs->opaque; 315 BdrvChild *active_disk = bs->file; 316 Error *local_err = NULL; 317 int ret; 318 319 if (!s->backup_job) { 320 error_setg(errp, "Backup job was cancelled unexpectedly"); 321 return; 322 } 323 324 backup_do_checkpoint(s->backup_job, &local_err); 325 if (local_err) { 326 error_propagate(errp, local_err); 327 return; 328 } 329 330 if (!active_disk->bs->drv) { 331 error_setg(errp, "Active disk %s is ejected", 332 active_disk->bs->node_name); 333 return; 334 } 335 336 ret = bdrv_make_empty(active_disk, errp); 337 if (ret < 0) { 338 return; 339 } 340 341 if (!s->hidden_disk->bs->drv) { 342 error_setg(errp, "Hidden disk %s is ejected", 343 s->hidden_disk->bs->node_name); 344 return; 345 } 346 347 ret = bdrv_make_empty(s->hidden_disk, errp); 348 if (ret < 0) { 349 return; 350 } 351 } 352 353 /* This function is supposed to be called twice: 354 * first with writable = true, then with writable = false. 355 * The first call puts s->hidden_disk and s->secondary_disk in 356 * r/w mode, and the second puts them back in their original state. 357 */ 358 static void reopen_backing_file(BlockDriverState *bs, bool writable, 359 Error **errp) 360 { 361 BDRVReplicationState *s = bs->opaque; 362 BdrvChild *hidden_disk, *secondary_disk; 363 BlockReopenQueue *reopen_queue = NULL; 364 365 /* 366 * s->hidden_disk and s->secondary_disk may not be set yet, as they will 367 * only be set after the children are writable. 368 */ 369 hidden_disk = bs->file->bs->backing; 370 secondary_disk = hidden_disk->bs->backing; 371 372 if (writable) { 373 s->orig_hidden_read_only = bdrv_is_read_only(hidden_disk->bs); 374 s->orig_secondary_read_only = bdrv_is_read_only(secondary_disk->bs); 375 } 376 377 if (s->orig_hidden_read_only) { 378 QDict *opts = qdict_new(); 379 qdict_put_bool(opts, BDRV_OPT_READ_ONLY, !writable); 380 reopen_queue = bdrv_reopen_queue(reopen_queue, hidden_disk->bs, 381 opts, true); 382 } 383 384 if (s->orig_secondary_read_only) { 385 QDict *opts = qdict_new(); 386 qdict_put_bool(opts, BDRV_OPT_READ_ONLY, !writable); 387 reopen_queue = bdrv_reopen_queue(reopen_queue, secondary_disk->bs, 388 opts, true); 389 } 390 391 if (reopen_queue) { 392 AioContext *ctx = bdrv_get_aio_context(bs); 393 if (ctx != qemu_get_aio_context()) { 394 aio_context_release(ctx); 395 } 396 bdrv_reopen_multiple(reopen_queue, errp); 397 if (ctx != qemu_get_aio_context()) { 398 aio_context_acquire(ctx); 399 } 400 } 401 } 402 403 static void backup_job_cleanup(BlockDriverState *bs) 404 { 405 BDRVReplicationState *s = bs->opaque; 406 BlockDriverState *top_bs; 407 408 s->backup_job = NULL; 409 410 top_bs = bdrv_lookup_bs(s->top_id, s->top_id, NULL); 411 if (!top_bs) { 412 return; 413 } 414 bdrv_op_unblock_all(top_bs, s->blocker); 415 error_free(s->blocker); 416 reopen_backing_file(bs, false, NULL); 417 } 418 419 static void backup_job_completed(void *opaque, int ret) 420 { 421 BlockDriverState *bs = opaque; 422 BDRVReplicationState *s = bs->opaque; 423 424 if (s->stage != BLOCK_REPLICATION_FAILOVER) { 425 /* The backup job is cancelled unexpectedly */ 426 s->error = -EIO; 427 } 428 429 backup_job_cleanup(bs); 430 } 431 432 static bool check_top_bs(BlockDriverState *top_bs, BlockDriverState *bs) 433 { 434 BdrvChild *child; 435 436 /* The bs itself is the top_bs */ 437 if (top_bs == bs) { 438 return true; 439 } 440 441 /* Iterate over top_bs's children */ 442 QLIST_FOREACH(child, &top_bs->children, next) { 443 if (child->bs == bs || check_top_bs(child->bs, bs)) { 444 return true; 445 } 446 } 447 448 return false; 449 } 450 451 static void replication_start(ReplicationState *rs, ReplicationMode mode, 452 Error **errp) 453 { 454 BlockDriverState *bs = rs->opaque; 455 BDRVReplicationState *s; 456 BlockDriverState *top_bs; 457 BdrvChild *active_disk, *hidden_disk, *secondary_disk; 458 int64_t active_length, hidden_length, disk_length; 459 AioContext *aio_context; 460 Error *local_err = NULL; 461 BackupPerf perf = { .use_copy_range = true, .max_workers = 1 }; 462 463 aio_context = bdrv_get_aio_context(bs); 464 aio_context_acquire(aio_context); 465 s = bs->opaque; 466 467 if (s->stage == BLOCK_REPLICATION_DONE || 468 s->stage == BLOCK_REPLICATION_FAILOVER) { 469 /* 470 * This case happens when a secondary is promoted to primary. 471 * Ignore the request because the secondary side of replication 472 * doesn't have to do anything anymore. 473 */ 474 aio_context_release(aio_context); 475 return; 476 } 477 478 if (s->stage != BLOCK_REPLICATION_NONE) { 479 error_setg(errp, "Block replication is running or done"); 480 aio_context_release(aio_context); 481 return; 482 } 483 484 if (s->mode != mode) { 485 error_setg(errp, "The parameter mode's value is invalid, needs %d," 486 " but got %d", s->mode, mode); 487 aio_context_release(aio_context); 488 return; 489 } 490 491 switch (s->mode) { 492 case REPLICATION_MODE_PRIMARY: 493 break; 494 case REPLICATION_MODE_SECONDARY: 495 active_disk = bs->file; 496 if (!active_disk || !active_disk->bs || !active_disk->bs->backing) { 497 error_setg(errp, "Active disk doesn't have backing file"); 498 aio_context_release(aio_context); 499 return; 500 } 501 502 hidden_disk = active_disk->bs->backing; 503 if (!hidden_disk->bs || !hidden_disk->bs->backing) { 504 error_setg(errp, "Hidden disk doesn't have backing file"); 505 aio_context_release(aio_context); 506 return; 507 } 508 509 secondary_disk = hidden_disk->bs->backing; 510 if (!secondary_disk->bs || !bdrv_has_blk(secondary_disk->bs)) { 511 error_setg(errp, "The secondary disk doesn't have block backend"); 512 aio_context_release(aio_context); 513 return; 514 } 515 516 /* verify the length */ 517 active_length = bdrv_getlength(active_disk->bs); 518 hidden_length = bdrv_getlength(hidden_disk->bs); 519 disk_length = bdrv_getlength(secondary_disk->bs); 520 if (active_length < 0 || hidden_length < 0 || disk_length < 0 || 521 active_length != hidden_length || hidden_length != disk_length) { 522 error_setg(errp, "Active disk, hidden disk, secondary disk's length" 523 " are not the same"); 524 aio_context_release(aio_context); 525 return; 526 } 527 528 /* Must be true, or the bdrv_getlength() calls would have failed */ 529 assert(active_disk->bs->drv && hidden_disk->bs->drv); 530 531 if (!active_disk->bs->drv->bdrv_make_empty || 532 !hidden_disk->bs->drv->bdrv_make_empty) { 533 error_setg(errp, 534 "Active disk or hidden disk doesn't support make_empty"); 535 aio_context_release(aio_context); 536 return; 537 } 538 539 /* reopen the backing file in r/w mode */ 540 reopen_backing_file(bs, true, &local_err); 541 if (local_err) { 542 error_propagate(errp, local_err); 543 aio_context_release(aio_context); 544 return; 545 } 546 547 bdrv_ref(hidden_disk->bs); 548 s->hidden_disk = bdrv_attach_child(bs, hidden_disk->bs, "hidden disk", 549 &child_of_bds, BDRV_CHILD_DATA, 550 &local_err); 551 if (local_err) { 552 error_propagate(errp, local_err); 553 aio_context_release(aio_context); 554 return; 555 } 556 557 bdrv_ref(secondary_disk->bs); 558 s->secondary_disk = bdrv_attach_child(bs, secondary_disk->bs, 559 "secondary disk", &child_of_bds, 560 BDRV_CHILD_DATA, &local_err); 561 if (local_err) { 562 error_propagate(errp, local_err); 563 aio_context_release(aio_context); 564 return; 565 } 566 567 /* start backup job now */ 568 error_setg(&s->blocker, 569 "Block device is in use by internal backup job"); 570 571 top_bs = bdrv_lookup_bs(s->top_id, s->top_id, NULL); 572 if (!top_bs || !bdrv_is_root_node(top_bs) || 573 !check_top_bs(top_bs, bs)) { 574 error_setg(errp, "No top_bs or it is invalid"); 575 reopen_backing_file(bs, false, NULL); 576 aio_context_release(aio_context); 577 return; 578 } 579 bdrv_op_block_all(top_bs, s->blocker); 580 bdrv_op_unblock(top_bs, BLOCK_OP_TYPE_DATAPLANE, s->blocker); 581 582 s->backup_job = backup_job_create( 583 NULL, s->secondary_disk->bs, s->hidden_disk->bs, 584 0, MIRROR_SYNC_MODE_NONE, NULL, 0, false, NULL, 585 &perf, 586 BLOCKDEV_ON_ERROR_REPORT, 587 BLOCKDEV_ON_ERROR_REPORT, JOB_INTERNAL, 588 backup_job_completed, bs, NULL, &local_err); 589 if (local_err) { 590 error_propagate(errp, local_err); 591 backup_job_cleanup(bs); 592 aio_context_release(aio_context); 593 return; 594 } 595 job_start(&s->backup_job->job); 596 break; 597 default: 598 aio_context_release(aio_context); 599 abort(); 600 } 601 602 s->stage = BLOCK_REPLICATION_RUNNING; 603 604 if (s->mode == REPLICATION_MODE_SECONDARY) { 605 secondary_do_checkpoint(bs, errp); 606 } 607 608 s->error = 0; 609 aio_context_release(aio_context); 610 } 611 612 static void replication_do_checkpoint(ReplicationState *rs, Error **errp) 613 { 614 BlockDriverState *bs = rs->opaque; 615 BDRVReplicationState *s; 616 AioContext *aio_context; 617 618 aio_context = bdrv_get_aio_context(bs); 619 aio_context_acquire(aio_context); 620 s = bs->opaque; 621 622 if (s->stage == BLOCK_REPLICATION_DONE || 623 s->stage == BLOCK_REPLICATION_FAILOVER) { 624 /* 625 * This case happens when a secondary was promoted to primary. 626 * Ignore the request because the secondary side of replication 627 * doesn't have to do anything anymore. 628 */ 629 aio_context_release(aio_context); 630 return; 631 } 632 633 if (s->mode == REPLICATION_MODE_SECONDARY) { 634 secondary_do_checkpoint(bs, errp); 635 } 636 aio_context_release(aio_context); 637 } 638 639 static void replication_get_error(ReplicationState *rs, Error **errp) 640 { 641 BlockDriverState *bs = rs->opaque; 642 BDRVReplicationState *s; 643 AioContext *aio_context; 644 645 aio_context = bdrv_get_aio_context(bs); 646 aio_context_acquire(aio_context); 647 s = bs->opaque; 648 649 if (s->stage == BLOCK_REPLICATION_NONE) { 650 error_setg(errp, "Block replication is not running"); 651 aio_context_release(aio_context); 652 return; 653 } 654 655 if (s->error) { 656 error_setg(errp, "I/O error occurred"); 657 aio_context_release(aio_context); 658 return; 659 } 660 aio_context_release(aio_context); 661 } 662 663 static void replication_done(void *opaque, int ret) 664 { 665 BlockDriverState *bs = opaque; 666 BDRVReplicationState *s = bs->opaque; 667 668 if (ret == 0) { 669 s->stage = BLOCK_REPLICATION_DONE; 670 671 bdrv_unref_child(bs, s->secondary_disk); 672 s->secondary_disk = NULL; 673 bdrv_unref_child(bs, s->hidden_disk); 674 s->hidden_disk = NULL; 675 s->error = 0; 676 } else { 677 s->stage = BLOCK_REPLICATION_FAILOVER_FAILED; 678 s->error = -EIO; 679 } 680 } 681 682 static void replication_stop(ReplicationState *rs, bool failover, Error **errp) 683 { 684 BlockDriverState *bs = rs->opaque; 685 BDRVReplicationState *s; 686 AioContext *aio_context; 687 688 aio_context = bdrv_get_aio_context(bs); 689 aio_context_acquire(aio_context); 690 s = bs->opaque; 691 692 if (s->stage == BLOCK_REPLICATION_DONE || 693 s->stage == BLOCK_REPLICATION_FAILOVER) { 694 /* 695 * This case happens when a secondary was promoted to primary. 696 * Ignore the request because the secondary side of replication 697 * doesn't have to do anything anymore. 698 */ 699 aio_context_release(aio_context); 700 return; 701 } 702 703 if (s->stage != BLOCK_REPLICATION_RUNNING) { 704 error_setg(errp, "Block replication is not running"); 705 aio_context_release(aio_context); 706 return; 707 } 708 709 switch (s->mode) { 710 case REPLICATION_MODE_PRIMARY: 711 s->stage = BLOCK_REPLICATION_DONE; 712 s->error = 0; 713 break; 714 case REPLICATION_MODE_SECONDARY: 715 /* 716 * This BDS will be closed, and the job should be completed 717 * before the BDS is closed, because we will access hidden 718 * disk, secondary disk in backup_job_completed(). 719 */ 720 if (s->backup_job) { 721 aio_context_release(aio_context); 722 job_cancel_sync(&s->backup_job->job, true); 723 aio_context_acquire(aio_context); 724 } 725 726 if (!failover) { 727 secondary_do_checkpoint(bs, errp); 728 s->stage = BLOCK_REPLICATION_DONE; 729 aio_context_release(aio_context); 730 return; 731 } 732 733 s->stage = BLOCK_REPLICATION_FAILOVER; 734 s->commit_job = commit_active_start( 735 NULL, bs->file->bs, s->secondary_disk->bs, 736 JOB_INTERNAL, 0, BLOCKDEV_ON_ERROR_REPORT, 737 NULL, replication_done, bs, true, errp); 738 break; 739 default: 740 aio_context_release(aio_context); 741 abort(); 742 } 743 aio_context_release(aio_context); 744 } 745 746 static const char *const replication_strong_runtime_opts[] = { 747 REPLICATION_MODE, 748 REPLICATION_TOP_ID, 749 750 NULL 751 }; 752 753 static BlockDriver bdrv_replication = { 754 .format_name = "replication", 755 .instance_size = sizeof(BDRVReplicationState), 756 757 .bdrv_open = replication_open, 758 .bdrv_close = replication_close, 759 .bdrv_child_perm = replication_child_perm, 760 761 .bdrv_getlength = replication_getlength, 762 .bdrv_co_readv = replication_co_readv, 763 .bdrv_co_writev = replication_co_writev, 764 765 .is_filter = true, 766 767 .has_variable_length = true, 768 .strong_runtime_opts = replication_strong_runtime_opts, 769 }; 770 771 static void bdrv_replication_init(void) 772 { 773 bdrv_register(&bdrv_replication); 774 } 775 776 block_init(bdrv_replication_init); 777