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