linux-user: Use safe_syscall for open and openat system calls
[qemu.git] / block / gluster.c
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);