1 /* 2 * GlusterFS backend for QEMU 3 * 4 * Copyright (C) 2012 Bharata B Rao <bharata@linux.vnet.ibm.com> 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 * See the COPYING file in the top-level directory. 8 * 9 */ 10 #include "qemu/osdep.h" 11 #include <glusterfs/api/glfs.h> 12 #include "block/block_int.h" 13 #include "qapi/error.h" 14 #include "qemu/uri.h" 15 16 typedef struct GlusterAIOCB { 17 int64_t size; 18 int ret; 19 QEMUBH *bh; 20 Coroutine *coroutine; 21 AioContext *aio_context; 22 } GlusterAIOCB; 23 24 typedef struct BDRVGlusterState { 25 struct glfs *glfs; 26 struct glfs_fd *fd; 27 } BDRVGlusterState; 28 29 typedef struct GlusterConf { 30 char *server; 31 int port; 32 char *volname; 33 char *image; 34 char *transport; 35 } GlusterConf; 36 37 static void qemu_gluster_gconf_free(GlusterConf *gconf) 38 { 39 if (gconf) { 40 g_free(gconf->server); 41 g_free(gconf->volname); 42 g_free(gconf->image); 43 g_free(gconf->transport); 44 g_free(gconf); 45 } 46 } 47 48 static int parse_volume_options(GlusterConf *gconf, char *path) 49 { 50 char *p, *q; 51 52 if (!path) { 53 return -EINVAL; 54 } 55 56 /* volume */ 57 p = q = path + strspn(path, "/"); 58 p += strcspn(p, "/"); 59 if (*p == '\0') { 60 return -EINVAL; 61 } 62 gconf->volname = g_strndup(q, p - q); 63 64 /* image */ 65 p += strspn(p, "/"); 66 if (*p == '\0') { 67 return -EINVAL; 68 } 69 gconf->image = g_strdup(p); 70 return 0; 71 } 72 73 /* 74 * file=gluster[+transport]://[server[:port]]/volname/image[?socket=...] 75 * 76 * 'gluster' is the protocol. 77 * 78 * 'transport' specifies the transport type used to connect to gluster 79 * management daemon (glusterd). Valid transport types are 80 * tcp, unix and rdma. If a transport type isn't specified, then tcp 81 * type is assumed. 82 * 83 * 'server' specifies the server where the volume file specification for 84 * the given volume resides. This can be either hostname, ipv4 address 85 * or ipv6 address. ipv6 address needs to be within square brackets [ ]. 86 * If transport type is 'unix', then 'server' field should not be specified. 87 * The 'socket' field needs to be populated with the path to unix domain 88 * socket. 89 * 90 * 'port' is the port number on which glusterd is listening. This is optional 91 * and if not specified, QEMU will send 0 which will make gluster to use the 92 * default port. If the transport type is unix, then 'port' should not be 93 * specified. 94 * 95 * 'volname' is the name of the gluster volume which contains the VM image. 96 * 97 * 'image' is the path to the actual VM image that resides on gluster volume. 98 * 99 * Examples: 100 * 101 * file=gluster://1.2.3.4/testvol/a.img 102 * file=gluster+tcp://1.2.3.4/testvol/a.img 103 * file=gluster+tcp://1.2.3.4:24007/testvol/dir/a.img 104 * file=gluster+tcp://[1:2:3:4:5:6:7:8]/testvol/dir/a.img 105 * file=gluster+tcp://[1:2:3:4:5:6:7:8]:24007/testvol/dir/a.img 106 * file=gluster+tcp://server.domain.com:24007/testvol/dir/a.img 107 * file=gluster+unix:///testvol/dir/a.img?socket=/tmp/glusterd.socket 108 * file=gluster+rdma://1.2.3.4:24007/testvol/a.img 109 */ 110 static int qemu_gluster_parseuri(GlusterConf *gconf, const char *filename) 111 { 112 URI *uri; 113 QueryParams *qp = NULL; 114 bool is_unix = false; 115 int ret = 0; 116 117 uri = uri_parse(filename); 118 if (!uri) { 119 return -EINVAL; 120 } 121 122 /* transport */ 123 if (!uri->scheme || !strcmp(uri->scheme, "gluster")) { 124 gconf->transport = g_strdup("tcp"); 125 } else if (!strcmp(uri->scheme, "gluster+tcp")) { 126 gconf->transport = g_strdup("tcp"); 127 } else if (!strcmp(uri->scheme, "gluster+unix")) { 128 gconf->transport = g_strdup("unix"); 129 is_unix = true; 130 } else if (!strcmp(uri->scheme, "gluster+rdma")) { 131 gconf->transport = g_strdup("rdma"); 132 } else { 133 ret = -EINVAL; 134 goto out; 135 } 136 137 ret = parse_volume_options(gconf, uri->path); 138 if (ret < 0) { 139 goto out; 140 } 141 142 qp = query_params_parse(uri->query); 143 if (qp->n > 1 || (is_unix && !qp->n) || (!is_unix && qp->n)) { 144 ret = -EINVAL; 145 goto out; 146 } 147 148 if (is_unix) { 149 if (uri->server || uri->port) { 150 ret = -EINVAL; 151 goto out; 152 } 153 if (strcmp(qp->p[0].name, "socket")) { 154 ret = -EINVAL; 155 goto out; 156 } 157 gconf->server = g_strdup(qp->p[0].value); 158 } else { 159 gconf->server = g_strdup(uri->server ? uri->server : "localhost"); 160 gconf->port = uri->port; 161 } 162 163 out: 164 if (qp) { 165 query_params_free(qp); 166 } 167 uri_free(uri); 168 return ret; 169 } 170 171 static struct glfs *qemu_gluster_init(GlusterConf *gconf, const char *filename, 172 Error **errp) 173 { 174 struct glfs *glfs = NULL; 175 int ret; 176 int old_errno; 177 178 ret = qemu_gluster_parseuri(gconf, filename); 179 if (ret < 0) { 180 error_setg(errp, "Usage: file=gluster[+transport]://[server[:port]]/" 181 "volname/image[?socket=...]"); 182 errno = -ret; 183 goto out; 184 } 185 186 glfs = glfs_new(gconf->volname); 187 if (!glfs) { 188 goto out; 189 } 190 191 ret = glfs_set_volfile_server(glfs, gconf->transport, gconf->server, 192 gconf->port); 193 if (ret < 0) { 194 goto out; 195 } 196 197 /* 198 * TODO: Use GF_LOG_ERROR instead of hard code value of 4 here when 199 * GlusterFS makes GF_LOG_* macros available to libgfapi users. 200 */ 201 ret = glfs_set_logging(glfs, "-", 4); 202 if (ret < 0) { 203 goto out; 204 } 205 206 ret = glfs_init(glfs); 207 if (ret) { 208 error_setg_errno(errp, errno, 209 "Gluster connection failed for server=%s port=%d " 210 "volume=%s image=%s transport=%s", gconf->server, 211 gconf->port, gconf->volname, gconf->image, 212 gconf->transport); 213 214 /* glfs_init sometimes doesn't set errno although docs suggest that */ 215 if (errno == 0) 216 errno = EINVAL; 217 218 goto out; 219 } 220 return glfs; 221 222 out: 223 if (glfs) { 224 old_errno = errno; 225 glfs_fini(glfs); 226 errno = old_errno; 227 } 228 return NULL; 229 } 230 231 static void qemu_gluster_complete_aio(void *opaque) 232 { 233 GlusterAIOCB *acb = (GlusterAIOCB *)opaque; 234 235 qemu_bh_delete(acb->bh); 236 acb->bh = NULL; 237 qemu_coroutine_enter(acb->coroutine, NULL); 238 } 239 240 /* 241 * AIO callback routine called from GlusterFS thread. 242 */ 243 static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg) 244 { 245 GlusterAIOCB *acb = (GlusterAIOCB *)arg; 246 247 if (!ret || ret == acb->size) { 248 acb->ret = 0; /* Success */ 249 } else if (ret < 0) { 250 acb->ret = -errno; /* Read/Write failed */ 251 } else { 252 acb->ret = -EIO; /* Partial read/write - fail it */ 253 } 254 255 acb->bh = aio_bh_new(acb->aio_context, qemu_gluster_complete_aio, acb); 256 qemu_bh_schedule(acb->bh); 257 } 258 259 /* TODO Convert to fine grained options */ 260 static QemuOptsList runtime_opts = { 261 .name = "gluster", 262 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), 263 .desc = { 264 { 265 .name = "filename", 266 .type = QEMU_OPT_STRING, 267 .help = "URL to the gluster image", 268 }, 269 { /* end of list */ } 270 }, 271 }; 272 273 static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags) 274 { 275 assert(open_flags != NULL); 276 277 *open_flags |= O_BINARY; 278 279 if (bdrv_flags & BDRV_O_RDWR) { 280 *open_flags |= O_RDWR; 281 } else { 282 *open_flags |= O_RDONLY; 283 } 284 285 if ((bdrv_flags & BDRV_O_NOCACHE)) { 286 *open_flags |= O_DIRECT; 287 } 288 } 289 290 static int qemu_gluster_open(BlockDriverState *bs, QDict *options, 291 int bdrv_flags, Error **errp) 292 { 293 BDRVGlusterState *s = bs->opaque; 294 int open_flags = 0; 295 int ret = 0; 296 GlusterConf *gconf = g_new0(GlusterConf, 1); 297 QemuOpts *opts; 298 Error *local_err = NULL; 299 const char *filename; 300 301 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); 302 qemu_opts_absorb_qdict(opts, options, &local_err); 303 if (local_err) { 304 error_propagate(errp, local_err); 305 ret = -EINVAL; 306 goto out; 307 } 308 309 filename = qemu_opt_get(opts, "filename"); 310 311 s->glfs = qemu_gluster_init(gconf, filename, errp); 312 if (!s->glfs) { 313 ret = -errno; 314 goto out; 315 } 316 317 #ifdef CONFIG_GLUSTERFS_XLATOR_OPT 318 /* Without this, if fsync fails for a recoverable reason (for instance, 319 * ENOSPC), gluster will dump its cache, preventing retries. This means 320 * almost certain data loss. Not all gluster versions support the 321 * 'resync-failed-syncs-after-fsync' key value, but there is no way to 322 * discover during runtime if it is supported (this api returns success for 323 * unknown key/value pairs) */ 324 ret = glfs_set_xlator_option(s->glfs, "*-write-behind", 325 "resync-failed-syncs-after-fsync", 326 "on"); 327 if (ret < 0) { 328 error_setg_errno(errp, errno, "Unable to set xlator key/value pair"); 329 ret = -errno; 330 goto out; 331 } 332 #endif 333 334 qemu_gluster_parse_flags(bdrv_flags, &open_flags); 335 336 s->fd = glfs_open(s->glfs, gconf->image, open_flags); 337 if (!s->fd) { 338 ret = -errno; 339 } 340 341 out: 342 qemu_opts_del(opts); 343 qemu_gluster_gconf_free(gconf); 344 if (!ret) { 345 return ret; 346 } 347 if (s->fd) { 348 glfs_close(s->fd); 349 } 350 if (s->glfs) { 351 glfs_fini(s->glfs); 352 } 353 return ret; 354 } 355 356 typedef struct BDRVGlusterReopenState { 357 struct glfs *glfs; 358 struct glfs_fd *fd; 359 } BDRVGlusterReopenState; 360 361 362 static int qemu_gluster_reopen_prepare(BDRVReopenState *state, 363 BlockReopenQueue *queue, Error **errp) 364 { 365 int ret = 0; 366 BDRVGlusterReopenState *reop_s; 367 GlusterConf *gconf = NULL; 368 int open_flags = 0; 369 370 assert(state != NULL); 371 assert(state->bs != NULL); 372 373 state->opaque = g_new0(BDRVGlusterReopenState, 1); 374 reop_s = state->opaque; 375 376 qemu_gluster_parse_flags(state->flags, &open_flags); 377 378 gconf = g_new0(GlusterConf, 1); 379 380 reop_s->glfs = qemu_gluster_init(gconf, state->bs->filename, errp); 381 if (reop_s->glfs == NULL) { 382 ret = -errno; 383 goto exit; 384 } 385 386 #ifdef CONFIG_GLUSTERFS_XLATOR_OPT 387 ret = glfs_set_xlator_option(reop_s->glfs, "*-write-behind", 388 "resync-failed-syncs-after-fsync", "on"); 389 if (ret < 0) { 390 error_setg_errno(errp, errno, "Unable to set xlator key/value pair"); 391 ret = -errno; 392 goto exit; 393 } 394 #endif 395 396 reop_s->fd = glfs_open(reop_s->glfs, gconf->image, open_flags); 397 if (reop_s->fd == NULL) { 398 /* reops->glfs will be cleaned up in _abort */ 399 ret = -errno; 400 goto exit; 401 } 402 403 exit: 404 /* state->opaque will be freed in either the _abort or _commit */ 405 qemu_gluster_gconf_free(gconf); 406 return ret; 407 } 408 409 static void qemu_gluster_reopen_commit(BDRVReopenState *state) 410 { 411 BDRVGlusterReopenState *reop_s = state->opaque; 412 BDRVGlusterState *s = state->bs->opaque; 413 414 415 /* close the old */ 416 if (s->fd) { 417 glfs_close(s->fd); 418 } 419 if (s->glfs) { 420 glfs_fini(s->glfs); 421 } 422 423 /* use the newly opened image / connection */ 424 s->fd = reop_s->fd; 425 s->glfs = reop_s->glfs; 426 427 g_free(state->opaque); 428 state->opaque = NULL; 429 430 return; 431 } 432 433 434 static void qemu_gluster_reopen_abort(BDRVReopenState *state) 435 { 436 BDRVGlusterReopenState *reop_s = state->opaque; 437 438 if (reop_s == NULL) { 439 return; 440 } 441 442 if (reop_s->fd) { 443 glfs_close(reop_s->fd); 444 } 445 446 if (reop_s->glfs) { 447 glfs_fini(reop_s->glfs); 448 } 449 450 g_free(state->opaque); 451 state->opaque = NULL; 452 453 return; 454 } 455 456 #ifdef CONFIG_GLUSTERFS_ZEROFILL 457 static coroutine_fn int qemu_gluster_co_write_zeroes(BlockDriverState *bs, 458 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags) 459 { 460 int ret; 461 GlusterAIOCB acb; 462 BDRVGlusterState *s = bs->opaque; 463 off_t size = nb_sectors * BDRV_SECTOR_SIZE; 464 off_t offset = sector_num * BDRV_SECTOR_SIZE; 465 466 acb.size = size; 467 acb.ret = 0; 468 acb.coroutine = qemu_coroutine_self(); 469 acb.aio_context = bdrv_get_aio_context(bs); 470 471 ret = glfs_zerofill_async(s->fd, offset, size, gluster_finish_aiocb, &acb); 472 if (ret < 0) { 473 return -errno; 474 } 475 476 qemu_coroutine_yield(); 477 return acb.ret; 478 } 479 480 static inline bool gluster_supports_zerofill(void) 481 { 482 return 1; 483 } 484 485 static inline int qemu_gluster_zerofill(struct glfs_fd *fd, int64_t offset, 486 int64_t size) 487 { 488 return glfs_zerofill(fd, offset, size); 489 } 490 491 #else 492 static inline bool gluster_supports_zerofill(void) 493 { 494 return 0; 495 } 496 497 static inline int qemu_gluster_zerofill(struct glfs_fd *fd, int64_t offset, 498 int64_t size) 499 { 500 return 0; 501 } 502 #endif 503 504 static int qemu_gluster_create(const char *filename, 505 QemuOpts *opts, Error **errp) 506 { 507 struct glfs *glfs; 508 struct glfs_fd *fd; 509 int ret = 0; 510 int prealloc = 0; 511 int64_t total_size = 0; 512 char *tmp = NULL; 513 GlusterConf *gconf = g_new0(GlusterConf, 1); 514 515 glfs = qemu_gluster_init(gconf, filename, errp); 516 if (!glfs) { 517 ret = -errno; 518 goto out; 519 } 520 521 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 522 BDRV_SECTOR_SIZE); 523 524 tmp = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 525 if (!tmp || !strcmp(tmp, "off")) { 526 prealloc = 0; 527 } else if (!strcmp(tmp, "full") && 528 gluster_supports_zerofill()) { 529 prealloc = 1; 530 } else { 531 error_setg(errp, "Invalid preallocation mode: '%s'" 532 " or GlusterFS doesn't support zerofill API", 533 tmp); 534 ret = -EINVAL; 535 goto out; 536 } 537 538 fd = glfs_creat(glfs, gconf->image, 539 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR); 540 if (!fd) { 541 ret = -errno; 542 } else { 543 if (!glfs_ftruncate(fd, total_size)) { 544 if (prealloc && qemu_gluster_zerofill(fd, 0, total_size)) { 545 ret = -errno; 546 } 547 } else { 548 ret = -errno; 549 } 550 551 if (glfs_close(fd) != 0) { 552 ret = -errno; 553 } 554 } 555 out: 556 g_free(tmp); 557 qemu_gluster_gconf_free(gconf); 558 if (glfs) { 559 glfs_fini(glfs); 560 } 561 return ret; 562 } 563 564 static coroutine_fn int qemu_gluster_co_rw(BlockDriverState *bs, 565 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int write) 566 { 567 int ret; 568 GlusterAIOCB acb; 569 BDRVGlusterState *s = bs->opaque; 570 size_t size = nb_sectors * BDRV_SECTOR_SIZE; 571 off_t offset = sector_num * BDRV_SECTOR_SIZE; 572 573 acb.size = size; 574 acb.ret = 0; 575 acb.coroutine = qemu_coroutine_self(); 576 acb.aio_context = bdrv_get_aio_context(bs); 577 578 if (write) { 579 ret = glfs_pwritev_async(s->fd, qiov->iov, qiov->niov, offset, 0, 580 gluster_finish_aiocb, &acb); 581 } else { 582 ret = glfs_preadv_async(s->fd, qiov->iov, qiov->niov, offset, 0, 583 gluster_finish_aiocb, &acb); 584 } 585 586 if (ret < 0) { 587 return -errno; 588 } 589 590 qemu_coroutine_yield(); 591 return acb.ret; 592 } 593 594 static int qemu_gluster_truncate(BlockDriverState *bs, int64_t offset) 595 { 596 int ret; 597 BDRVGlusterState *s = bs->opaque; 598 599 ret = glfs_ftruncate(s->fd, offset); 600 if (ret < 0) { 601 return -errno; 602 } 603 604 return 0; 605 } 606 607 static coroutine_fn int qemu_gluster_co_readv(BlockDriverState *bs, 608 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) 609 { 610 return qemu_gluster_co_rw(bs, sector_num, nb_sectors, qiov, 0); 611 } 612 613 static coroutine_fn int qemu_gluster_co_writev(BlockDriverState *bs, 614 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) 615 { 616 return qemu_gluster_co_rw(bs, sector_num, nb_sectors, qiov, 1); 617 } 618 619 static void qemu_gluster_close(BlockDriverState *bs) 620 { 621 BDRVGlusterState *s = bs->opaque; 622 623 if (s->fd) { 624 glfs_close(s->fd); 625 s->fd = NULL; 626 } 627 glfs_fini(s->glfs); 628 } 629 630 static coroutine_fn int qemu_gluster_co_flush_to_disk(BlockDriverState *bs) 631 { 632 int ret; 633 GlusterAIOCB acb; 634 BDRVGlusterState *s = bs->opaque; 635 636 acb.size = 0; 637 acb.ret = 0; 638 acb.coroutine = qemu_coroutine_self(); 639 acb.aio_context = bdrv_get_aio_context(bs); 640 641 ret = glfs_fsync_async(s->fd, gluster_finish_aiocb, &acb); 642 if (ret < 0) { 643 ret = -errno; 644 goto error; 645 } 646 647 qemu_coroutine_yield(); 648 if (acb.ret < 0) { 649 ret = acb.ret; 650 goto error; 651 } 652 653 return acb.ret; 654 655 error: 656 /* Some versions of Gluster (3.5.6 -> 3.5.8?) will not retain its cache 657 * after a fsync failure, so we have no way of allowing the guest to safely 658 * continue. Gluster versions prior to 3.5.6 don't retain the cache 659 * either, but will invalidate the fd on error, so this is again our only 660 * option. 661 * 662 * The 'resync-failed-syncs-after-fsync' xlator option for the 663 * write-behind cache will cause later gluster versions to retain its 664 * cache after error, so long as the fd remains open. However, we 665 * currently have no way of knowing if this option is supported. 666 * 667 * TODO: Once gluster provides a way for us to determine if the option 668 * is supported, bypass the closure and setting drv to NULL. */ 669 qemu_gluster_close(bs); 670 bs->drv = NULL; 671 return ret; 672 } 673 674 #ifdef CONFIG_GLUSTERFS_DISCARD 675 static coroutine_fn int qemu_gluster_co_discard(BlockDriverState *bs, 676 int64_t sector_num, int nb_sectors) 677 { 678 int ret; 679 GlusterAIOCB acb; 680 BDRVGlusterState *s = bs->opaque; 681 size_t size = nb_sectors * BDRV_SECTOR_SIZE; 682 off_t offset = sector_num * BDRV_SECTOR_SIZE; 683 684 acb.size = 0; 685 acb.ret = 0; 686 acb.coroutine = qemu_coroutine_self(); 687 acb.aio_context = bdrv_get_aio_context(bs); 688 689 ret = glfs_discard_async(s->fd, offset, size, gluster_finish_aiocb, &acb); 690 if (ret < 0) { 691 return -errno; 692 } 693 694 qemu_coroutine_yield(); 695 return acb.ret; 696 } 697 #endif 698 699 static int64_t qemu_gluster_getlength(BlockDriverState *bs) 700 { 701 BDRVGlusterState *s = bs->opaque; 702 int64_t ret; 703 704 ret = glfs_lseek(s->fd, 0, SEEK_END); 705 if (ret < 0) { 706 return -errno; 707 } else { 708 return ret; 709 } 710 } 711 712 static int64_t qemu_gluster_allocated_file_size(BlockDriverState *bs) 713 { 714 BDRVGlusterState *s = bs->opaque; 715 struct stat st; 716 int ret; 717 718 ret = glfs_fstat(s->fd, &st); 719 if (ret < 0) { 720 return -errno; 721 } else { 722 return st.st_blocks * 512; 723 } 724 } 725 726 static int qemu_gluster_has_zero_init(BlockDriverState *bs) 727 { 728 /* GlusterFS volume could be backed by a block device */ 729 return 0; 730 } 731 732 static QemuOptsList qemu_gluster_create_opts = { 733 .name = "qemu-gluster-create-opts", 734 .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head), 735 .desc = { 736 { 737 .name = BLOCK_OPT_SIZE, 738 .type = QEMU_OPT_SIZE, 739 .help = "Virtual disk size" 740 }, 741 { 742 .name = BLOCK_OPT_PREALLOC, 743 .type = QEMU_OPT_STRING, 744 .help = "Preallocation mode (allowed values: off, full)" 745 }, 746 { /* end of list */ } 747 } 748 }; 749 750 static BlockDriver bdrv_gluster = { 751 .format_name = "gluster", 752 .protocol_name = "gluster", 753 .instance_size = sizeof(BDRVGlusterState), 754 .bdrv_needs_filename = true, 755 .bdrv_file_open = qemu_gluster_open, 756 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 757 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 758 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 759 .bdrv_close = qemu_gluster_close, 760 .bdrv_create = qemu_gluster_create, 761 .bdrv_getlength = qemu_gluster_getlength, 762 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 763 .bdrv_truncate = qemu_gluster_truncate, 764 .bdrv_co_readv = qemu_gluster_co_readv, 765 .bdrv_co_writev = qemu_gluster_co_writev, 766 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 767 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 768 #ifdef CONFIG_GLUSTERFS_DISCARD 769 .bdrv_co_discard = qemu_gluster_co_discard, 770 #endif 771 #ifdef CONFIG_GLUSTERFS_ZEROFILL 772 .bdrv_co_write_zeroes = qemu_gluster_co_write_zeroes, 773 #endif 774 .create_opts = &qemu_gluster_create_opts, 775 }; 776 777 static BlockDriver bdrv_gluster_tcp = { 778 .format_name = "gluster", 779 .protocol_name = "gluster+tcp", 780 .instance_size = sizeof(BDRVGlusterState), 781 .bdrv_needs_filename = true, 782 .bdrv_file_open = qemu_gluster_open, 783 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 784 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 785 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 786 .bdrv_close = qemu_gluster_close, 787 .bdrv_create = qemu_gluster_create, 788 .bdrv_getlength = qemu_gluster_getlength, 789 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 790 .bdrv_truncate = qemu_gluster_truncate, 791 .bdrv_co_readv = qemu_gluster_co_readv, 792 .bdrv_co_writev = qemu_gluster_co_writev, 793 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 794 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 795 #ifdef CONFIG_GLUSTERFS_DISCARD 796 .bdrv_co_discard = qemu_gluster_co_discard, 797 #endif 798 #ifdef CONFIG_GLUSTERFS_ZEROFILL 799 .bdrv_co_write_zeroes = qemu_gluster_co_write_zeroes, 800 #endif 801 .create_opts = &qemu_gluster_create_opts, 802 }; 803 804 static BlockDriver bdrv_gluster_unix = { 805 .format_name = "gluster", 806 .protocol_name = "gluster+unix", 807 .instance_size = sizeof(BDRVGlusterState), 808 .bdrv_needs_filename = true, 809 .bdrv_file_open = qemu_gluster_open, 810 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 811 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 812 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 813 .bdrv_close = qemu_gluster_close, 814 .bdrv_create = qemu_gluster_create, 815 .bdrv_getlength = qemu_gluster_getlength, 816 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 817 .bdrv_truncate = qemu_gluster_truncate, 818 .bdrv_co_readv = qemu_gluster_co_readv, 819 .bdrv_co_writev = qemu_gluster_co_writev, 820 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 821 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 822 #ifdef CONFIG_GLUSTERFS_DISCARD 823 .bdrv_co_discard = qemu_gluster_co_discard, 824 #endif 825 #ifdef CONFIG_GLUSTERFS_ZEROFILL 826 .bdrv_co_write_zeroes = qemu_gluster_co_write_zeroes, 827 #endif 828 .create_opts = &qemu_gluster_create_opts, 829 }; 830 831 static BlockDriver bdrv_gluster_rdma = { 832 .format_name = "gluster", 833 .protocol_name = "gluster+rdma", 834 .instance_size = sizeof(BDRVGlusterState), 835 .bdrv_needs_filename = true, 836 .bdrv_file_open = qemu_gluster_open, 837 .bdrv_reopen_prepare = qemu_gluster_reopen_prepare, 838 .bdrv_reopen_commit = qemu_gluster_reopen_commit, 839 .bdrv_reopen_abort = qemu_gluster_reopen_abort, 840 .bdrv_close = qemu_gluster_close, 841 .bdrv_create = qemu_gluster_create, 842 .bdrv_getlength = qemu_gluster_getlength, 843 .bdrv_get_allocated_file_size = qemu_gluster_allocated_file_size, 844 .bdrv_truncate = qemu_gluster_truncate, 845 .bdrv_co_readv = qemu_gluster_co_readv, 846 .bdrv_co_writev = qemu_gluster_co_writev, 847 .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk, 848 .bdrv_has_zero_init = qemu_gluster_has_zero_init, 849 #ifdef CONFIG_GLUSTERFS_DISCARD 850 .bdrv_co_discard = qemu_gluster_co_discard, 851 #endif 852 #ifdef CONFIG_GLUSTERFS_ZEROFILL 853 .bdrv_co_write_zeroes = qemu_gluster_co_write_zeroes, 854 #endif 855 .create_opts = &qemu_gluster_create_opts, 856 }; 857 858 static void bdrv_gluster_init(void) 859 { 860 bdrv_register(&bdrv_gluster_rdma); 861 bdrv_register(&bdrv_gluster_unix); 862 bdrv_register(&bdrv_gluster_tcp); 863 bdrv_register(&bdrv_gluster); 864 } 865 866 block_init(bdrv_gluster_init); 867