18d6d89cbSBharata B Rao /*
28d6d89cbSBharata B Rao * GlusterFS backend for QEMU
38d6d89cbSBharata B Rao *
48d6d89cbSBharata B Rao * Copyright (C) 2012 Bharata B Rao <bharata@linux.vnet.ibm.com>
58d6d89cbSBharata B Rao *
685c09bc0SBharata B Rao * This work is licensed under the terms of the GNU GPL, version 2 or later.
785c09bc0SBharata B Rao * See the COPYING file in the top-level directory.
88d6d89cbSBharata B Rao *
98d6d89cbSBharata B Rao */
10922a01a0SMarkus Armbruster
1180c71a24SPeter Maydell #include "qemu/osdep.h"
12de23e72bSStefano Garzarella #include "qemu/units.h"
138d6d89cbSBharata B Rao #include <glusterfs/api/glfs.h>
14e2c1c34fSMarkus Armbruster #include "block/block-io.h"
15737e150eSPaolo Bonzini #include "block/block_int.h"
16609f45eaSMax Reitz #include "block/qdict.h"
17da34e65cSMarkus Armbruster #include "qapi/error.h"
18452fcdbcSMarkus Armbruster #include "qapi/qmp/qdict.h"
196c7189bbSPrasanna Kumar Kalever #include "qapi/qmp/qerror.h"
201de7afc9SPaolo Bonzini #include "qemu/uri.h"
210552ff24SPrasanna Kumar Kalever #include "qemu/error-report.h"
220b8fa32fSMarkus Armbruster #include "qemu/module.h"
23922a01a0SMarkus Armbruster #include "qemu/option.h"
24c56ac33bSPrasanna Kumar Kalever #include "qemu/cutils.h"
258d6d89cbSBharata B Rao
26e014dbe7SPrasanna Kumar Kalever #ifdef CONFIG_GLUSTERFS_FTRUNCATE_HAS_STAT
27e014dbe7SPrasanna Kumar Kalever # define glfs_ftruncate(fd, offset) glfs_ftruncate(fd, offset, NULL, NULL)
28e014dbe7SPrasanna Kumar Kalever #endif
29e014dbe7SPrasanna Kumar Kalever
30f70c50c8SPrasanna Kumar Kalever #define GLUSTER_OPT_FILENAME "filename"
316c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_VOLUME "volume"
326c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_PATH "path"
336c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_TYPE "type"
346c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_SERVER_PATTERN "server."
356c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_HOST "host"
366c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_PORT "port"
376c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_TO "to"
386c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_IPV4 "ipv4"
396c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_IPV6 "ipv6"
406c7189bbSPrasanna Kumar Kalever #define GLUSTER_OPT_SOCKET "socket"
41f70c50c8SPrasanna Kumar Kalever #define GLUSTER_OPT_DEBUG "debug"
427edac2ddSPrasanna Kumar Kalever #define GLUSTER_DEFAULT_PORT 24007
43f70c50c8SPrasanna Kumar Kalever #define GLUSTER_DEBUG_DEFAULT 4
44f70c50c8SPrasanna Kumar Kalever #define GLUSTER_DEBUG_MAX 9
45e9db8ff3SPrasanna Kumar Kalever #define GLUSTER_OPT_LOGFILE "logfile"
46e9db8ff3SPrasanna Kumar Kalever #define GLUSTER_LOGFILE_DEFAULT "-" /* handled in libgfapi as /dev/stderr */
47de23e72bSStefano Garzarella /*
48de23e72bSStefano Garzarella * Several versions of GlusterFS (3.12? -> 6.0.1) fail when the transfer size
49de23e72bSStefano Garzarella * is greater or equal to 1024 MiB, so we are limiting the transfer size to 512
50de23e72bSStefano Garzarella * MiB to avoid this rare issue.
51de23e72bSStefano Garzarella */
52de23e72bSStefano Garzarella #define GLUSTER_MAX_TRANSFER (512 * MiB)
53f70c50c8SPrasanna Kumar Kalever
546c7189bbSPrasanna Kumar Kalever #define GERR_INDEX_HINT "hint: check in 'server' array index '%d'\n"
55f70c50c8SPrasanna Kumar Kalever
568d6d89cbSBharata B Rao typedef struct GlusterAIOCB {
578d6d89cbSBharata B Rao int64_t size;
588d6d89cbSBharata B Rao int ret;
5915744b0bSBharata B Rao Coroutine *coroutine;
606ee50af2SStefan Hajnoczi AioContext *aio_context;
618d6d89cbSBharata B Rao } GlusterAIOCB;
628d6d89cbSBharata B Rao
638d6d89cbSBharata B Rao typedef struct BDRVGlusterState {
648d6d89cbSBharata B Rao struct glfs *glfs;
658d6d89cbSBharata B Rao struct glfs_fd *fd;
66e9db8ff3SPrasanna Kumar Kalever char *logfile;
67947eb203SNiels de Vos bool supports_seek_data;
681a417e46SPrasanna Kumar Kalever int debug;
698d6d89cbSBharata B Rao } BDRVGlusterState;
708d6d89cbSBharata B Rao
71f70c50c8SPrasanna Kumar Kalever typedef struct BDRVGlusterReopenState {
72f70c50c8SPrasanna Kumar Kalever struct glfs *glfs;
73f70c50c8SPrasanna Kumar Kalever struct glfs_fd *fd;
74f70c50c8SPrasanna Kumar Kalever } BDRVGlusterReopenState;
75f70c50c8SPrasanna Kumar Kalever
76f70c50c8SPrasanna Kumar Kalever
776349c154SPrasanna Kumar Kalever typedef struct GlfsPreopened {
786349c154SPrasanna Kumar Kalever char *volume;
796349c154SPrasanna Kumar Kalever glfs_t *fs;
806349c154SPrasanna Kumar Kalever int ref;
816349c154SPrasanna Kumar Kalever } GlfsPreopened;
826349c154SPrasanna Kumar Kalever
836349c154SPrasanna Kumar Kalever typedef struct ListElement {
846349c154SPrasanna Kumar Kalever QLIST_ENTRY(ListElement) list;
856349c154SPrasanna Kumar Kalever GlfsPreopened saved;
866349c154SPrasanna Kumar Kalever } ListElement;
876349c154SPrasanna Kumar Kalever
88b58deb34SPaolo Bonzini static QLIST_HEAD(, ListElement) glfs_list;
896349c154SPrasanna Kumar Kalever
90f70c50c8SPrasanna Kumar Kalever static QemuOptsList qemu_gluster_create_opts = {
91f70c50c8SPrasanna Kumar Kalever .name = "qemu-gluster-create-opts",
92f70c50c8SPrasanna Kumar Kalever .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head),
93f70c50c8SPrasanna Kumar Kalever .desc = {
94f70c50c8SPrasanna Kumar Kalever {
95f70c50c8SPrasanna Kumar Kalever .name = BLOCK_OPT_SIZE,
96f70c50c8SPrasanna Kumar Kalever .type = QEMU_OPT_SIZE,
97f70c50c8SPrasanna Kumar Kalever .help = "Virtual disk size"
98f70c50c8SPrasanna Kumar Kalever },
99f70c50c8SPrasanna Kumar Kalever {
100f70c50c8SPrasanna Kumar Kalever .name = BLOCK_OPT_PREALLOC,
101f70c50c8SPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
1022ea8e96dSStefano Garzarella .help = "Preallocation mode (allowed values: off"
1032ea8e96dSStefano Garzarella #ifdef CONFIG_GLUSTERFS_FALLOCATE
1042ea8e96dSStefano Garzarella ", falloc"
1052ea8e96dSStefano Garzarella #endif
1062ea8e96dSStefano Garzarella #ifdef CONFIG_GLUSTERFS_ZEROFILL
1072ea8e96dSStefano Garzarella ", full"
1082ea8e96dSStefano Garzarella #endif
1092ea8e96dSStefano Garzarella ")"
110f70c50c8SPrasanna Kumar Kalever },
111f70c50c8SPrasanna Kumar Kalever {
112f70c50c8SPrasanna Kumar Kalever .name = GLUSTER_OPT_DEBUG,
113f70c50c8SPrasanna Kumar Kalever .type = QEMU_OPT_NUMBER,
114f70c50c8SPrasanna Kumar Kalever .help = "Gluster log level, valid range is 0-9",
115f70c50c8SPrasanna Kumar Kalever },
116e9db8ff3SPrasanna Kumar Kalever {
117e9db8ff3SPrasanna Kumar Kalever .name = GLUSTER_OPT_LOGFILE,
118e9db8ff3SPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
119e9db8ff3SPrasanna Kumar Kalever .help = "Logfile path of libgfapi",
120e9db8ff3SPrasanna Kumar Kalever },
121f70c50c8SPrasanna Kumar Kalever { /* end of list */ }
122f70c50c8SPrasanna Kumar Kalever }
123f70c50c8SPrasanna Kumar Kalever };
124f70c50c8SPrasanna Kumar Kalever
125f70c50c8SPrasanna Kumar Kalever static QemuOptsList runtime_opts = {
126f70c50c8SPrasanna Kumar Kalever .name = "gluster",
127f70c50c8SPrasanna Kumar Kalever .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
128f70c50c8SPrasanna Kumar Kalever .desc = {
129f70c50c8SPrasanna Kumar Kalever {
130f70c50c8SPrasanna Kumar Kalever .name = GLUSTER_OPT_FILENAME,
131f70c50c8SPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
132f70c50c8SPrasanna Kumar Kalever .help = "URL to the gluster image",
133f70c50c8SPrasanna Kumar Kalever },
134f70c50c8SPrasanna Kumar Kalever {
135f70c50c8SPrasanna Kumar Kalever .name = GLUSTER_OPT_DEBUG,
136f70c50c8SPrasanna Kumar Kalever .type = QEMU_OPT_NUMBER,
137f70c50c8SPrasanna Kumar Kalever .help = "Gluster log level, valid range is 0-9",
138f70c50c8SPrasanna Kumar Kalever },
139e9db8ff3SPrasanna Kumar Kalever {
140e9db8ff3SPrasanna Kumar Kalever .name = GLUSTER_OPT_LOGFILE,
141e9db8ff3SPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
142e9db8ff3SPrasanna Kumar Kalever .help = "Logfile path of libgfapi",
143e9db8ff3SPrasanna Kumar Kalever },
144f70c50c8SPrasanna Kumar Kalever { /* end of list */ }
145f70c50c8SPrasanna Kumar Kalever },
146f70c50c8SPrasanna Kumar Kalever };
147f70c50c8SPrasanna Kumar Kalever
1486c7189bbSPrasanna Kumar Kalever static QemuOptsList runtime_json_opts = {
1496c7189bbSPrasanna Kumar Kalever .name = "gluster_json",
1506c7189bbSPrasanna Kumar Kalever .head = QTAILQ_HEAD_INITIALIZER(runtime_json_opts.head),
1516c7189bbSPrasanna Kumar Kalever .desc = {
1526c7189bbSPrasanna Kumar Kalever {
1536c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_VOLUME,
1546c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
1556c7189bbSPrasanna Kumar Kalever .help = "name of gluster volume where VM image resides",
1566c7189bbSPrasanna Kumar Kalever },
1576c7189bbSPrasanna Kumar Kalever {
1586c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_PATH,
1596c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
1606c7189bbSPrasanna Kumar Kalever .help = "absolute path to image file in gluster volume",
1616c7189bbSPrasanna Kumar Kalever },
1626c7189bbSPrasanna Kumar Kalever {
1636c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_DEBUG,
1646c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_NUMBER,
1656c7189bbSPrasanna Kumar Kalever .help = "Gluster log level, valid range is 0-9",
1666c7189bbSPrasanna Kumar Kalever },
1676c7189bbSPrasanna Kumar Kalever { /* end of list */ }
1686c7189bbSPrasanna Kumar Kalever },
1696c7189bbSPrasanna Kumar Kalever };
1706c7189bbSPrasanna Kumar Kalever
1716c7189bbSPrasanna Kumar Kalever static QemuOptsList runtime_type_opts = {
1726c7189bbSPrasanna Kumar Kalever .name = "gluster_type",
1736c7189bbSPrasanna Kumar Kalever .head = QTAILQ_HEAD_INITIALIZER(runtime_type_opts.head),
1746c7189bbSPrasanna Kumar Kalever .desc = {
1756c7189bbSPrasanna Kumar Kalever {
1766c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_TYPE,
1776c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
178c5f1ae3aSMarkus Armbruster .help = "inet|unix",
1796c7189bbSPrasanna Kumar Kalever },
1806c7189bbSPrasanna Kumar Kalever { /* end of list */ }
1816c7189bbSPrasanna Kumar Kalever },
1826c7189bbSPrasanna Kumar Kalever };
1836c7189bbSPrasanna Kumar Kalever
1846c7189bbSPrasanna Kumar Kalever static QemuOptsList runtime_unix_opts = {
1856c7189bbSPrasanna Kumar Kalever .name = "gluster_unix",
1866c7189bbSPrasanna Kumar Kalever .head = QTAILQ_HEAD_INITIALIZER(runtime_unix_opts.head),
1876c7189bbSPrasanna Kumar Kalever .desc = {
1886c7189bbSPrasanna Kumar Kalever {
1896c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_SOCKET,
1906c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
1919dae635aSKevin Wolf .help = "socket file path (legacy)",
1929dae635aSKevin Wolf },
1939dae635aSKevin Wolf {
1949dae635aSKevin Wolf .name = GLUSTER_OPT_PATH,
1959dae635aSKevin Wolf .type = QEMU_OPT_STRING,
1969dae635aSKevin Wolf .help = "socket file path (QAPI)",
1976c7189bbSPrasanna Kumar Kalever },
1986c7189bbSPrasanna Kumar Kalever { /* end of list */ }
1996c7189bbSPrasanna Kumar Kalever },
2006c7189bbSPrasanna Kumar Kalever };
2016c7189bbSPrasanna Kumar Kalever
202c5f1ae3aSMarkus Armbruster static QemuOptsList runtime_inet_opts = {
203c5f1ae3aSMarkus Armbruster .name = "gluster_inet",
204c5f1ae3aSMarkus Armbruster .head = QTAILQ_HEAD_INITIALIZER(runtime_inet_opts.head),
2056c7189bbSPrasanna Kumar Kalever .desc = {
2066c7189bbSPrasanna Kumar Kalever {
2076c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_TYPE,
2086c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
209c5f1ae3aSMarkus Armbruster .help = "inet|unix",
2106c7189bbSPrasanna Kumar Kalever },
2116c7189bbSPrasanna Kumar Kalever {
2126c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_HOST,
2136c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
2146c7189bbSPrasanna Kumar Kalever .help = "host address (hostname/ipv4/ipv6 addresses)",
2156c7189bbSPrasanna Kumar Kalever },
2166c7189bbSPrasanna Kumar Kalever {
2176c7189bbSPrasanna Kumar Kalever .name = GLUSTER_OPT_PORT,
21853d9837fSPrasanna Kumar Kalever .type = QEMU_OPT_STRING,
2196c7189bbSPrasanna Kumar Kalever .help = "port number on which glusterd is listening (default 24007)",
2206c7189bbSPrasanna Kumar Kalever },
2216c7189bbSPrasanna Kumar Kalever {
2226c7189bbSPrasanna Kumar Kalever .name = "to",
2236c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_NUMBER,
2246c7189bbSPrasanna Kumar Kalever .help = "max port number, not supported by gluster",
2256c7189bbSPrasanna Kumar Kalever },
2266c7189bbSPrasanna Kumar Kalever {
2276c7189bbSPrasanna Kumar Kalever .name = "ipv4",
2286c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_BOOL,
2296c7189bbSPrasanna Kumar Kalever .help = "ipv4 bool value, not supported by gluster",
2306c7189bbSPrasanna Kumar Kalever },
2316c7189bbSPrasanna Kumar Kalever {
2326c7189bbSPrasanna Kumar Kalever .name = "ipv6",
2336c7189bbSPrasanna Kumar Kalever .type = QEMU_OPT_BOOL,
2346c7189bbSPrasanna Kumar Kalever .help = "ipv6 bool value, not supported by gluster",
2356c7189bbSPrasanna Kumar Kalever },
2366c7189bbSPrasanna Kumar Kalever { /* end of list */ }
2376c7189bbSPrasanna Kumar Kalever },
2386c7189bbSPrasanna Kumar Kalever };
239f70c50c8SPrasanna Kumar Kalever
glfs_set_preopened(const char * volume,glfs_t * fs)2406349c154SPrasanna Kumar Kalever static void glfs_set_preopened(const char *volume, glfs_t *fs)
2416349c154SPrasanna Kumar Kalever {
2426349c154SPrasanna Kumar Kalever ListElement *entry = NULL;
2436349c154SPrasanna Kumar Kalever
2446349c154SPrasanna Kumar Kalever entry = g_new(ListElement, 1);
2456349c154SPrasanna Kumar Kalever
2466349c154SPrasanna Kumar Kalever entry->saved.volume = g_strdup(volume);
2476349c154SPrasanna Kumar Kalever
2486349c154SPrasanna Kumar Kalever entry->saved.fs = fs;
2496349c154SPrasanna Kumar Kalever entry->saved.ref = 1;
2506349c154SPrasanna Kumar Kalever
2516349c154SPrasanna Kumar Kalever QLIST_INSERT_HEAD(&glfs_list, entry, list);
2526349c154SPrasanna Kumar Kalever }
2536349c154SPrasanna Kumar Kalever
glfs_find_preopened(const char * volume)2546349c154SPrasanna Kumar Kalever static glfs_t *glfs_find_preopened(const char *volume)
2556349c154SPrasanna Kumar Kalever {
2566349c154SPrasanna Kumar Kalever ListElement *entry = NULL;
2576349c154SPrasanna Kumar Kalever
2586349c154SPrasanna Kumar Kalever QLIST_FOREACH(entry, &glfs_list, list) {
2596349c154SPrasanna Kumar Kalever if (strcmp(entry->saved.volume, volume) == 0) {
2606349c154SPrasanna Kumar Kalever entry->saved.ref++;
2616349c154SPrasanna Kumar Kalever return entry->saved.fs;
2626349c154SPrasanna Kumar Kalever }
2636349c154SPrasanna Kumar Kalever }
2646349c154SPrasanna Kumar Kalever
2656349c154SPrasanna Kumar Kalever return NULL;
2666349c154SPrasanna Kumar Kalever }
2676349c154SPrasanna Kumar Kalever
glfs_clear_preopened(glfs_t * fs)2686349c154SPrasanna Kumar Kalever static void glfs_clear_preopened(glfs_t *fs)
2696349c154SPrasanna Kumar Kalever {
2706349c154SPrasanna Kumar Kalever ListElement *entry = NULL;
271668c0e44SKevin Wolf ListElement *next;
2726349c154SPrasanna Kumar Kalever
2736349c154SPrasanna Kumar Kalever if (fs == NULL) {
2746349c154SPrasanna Kumar Kalever return;
2756349c154SPrasanna Kumar Kalever }
2766349c154SPrasanna Kumar Kalever
277668c0e44SKevin Wolf QLIST_FOREACH_SAFE(entry, &glfs_list, list, next) {
2786349c154SPrasanna Kumar Kalever if (entry->saved.fs == fs) {
2796349c154SPrasanna Kumar Kalever if (--entry->saved.ref) {
2806349c154SPrasanna Kumar Kalever return;
2816349c154SPrasanna Kumar Kalever }
2826349c154SPrasanna Kumar Kalever
2836349c154SPrasanna Kumar Kalever QLIST_REMOVE(entry, list);
2846349c154SPrasanna Kumar Kalever
2856349c154SPrasanna Kumar Kalever glfs_fini(entry->saved.fs);
2866349c154SPrasanna Kumar Kalever g_free(entry->saved.volume);
2876349c154SPrasanna Kumar Kalever g_free(entry);
2886349c154SPrasanna Kumar Kalever }
2896349c154SPrasanna Kumar Kalever }
2906349c154SPrasanna Kumar Kalever }
2916349c154SPrasanna Kumar Kalever
parse_volume_options(BlockdevOptionsGluster * gconf,char * path)2927edac2ddSPrasanna Kumar Kalever static int parse_volume_options(BlockdevOptionsGluster *gconf, char *path)
2938d6d89cbSBharata B Rao {
2948d6d89cbSBharata B Rao char *p, *q;
2958d6d89cbSBharata B Rao
2968d6d89cbSBharata B Rao if (!path) {
2978d6d89cbSBharata B Rao return -EINVAL;
2988d6d89cbSBharata B Rao }
2998d6d89cbSBharata B Rao
3008d6d89cbSBharata B Rao /* volume */
3018d6d89cbSBharata B Rao p = q = path + strspn(path, "/");
3028d6d89cbSBharata B Rao p += strcspn(p, "/");
3038d6d89cbSBharata B Rao if (*p == '\0') {
3048d6d89cbSBharata B Rao return -EINVAL;
3058d6d89cbSBharata B Rao }
306d5cf4079SPrasanna Kumar Kalever gconf->volume = g_strndup(q, p - q);
3078d6d89cbSBharata B Rao
308d5cf4079SPrasanna Kumar Kalever /* path */
3098d6d89cbSBharata B Rao p += strspn(p, "/");
3108d6d89cbSBharata B Rao if (*p == '\0') {
3118d6d89cbSBharata B Rao return -EINVAL;
3128d6d89cbSBharata B Rao }
313d5cf4079SPrasanna Kumar Kalever gconf->path = g_strdup(p);
3148d6d89cbSBharata B Rao return 0;
3158d6d89cbSBharata B Rao }
3168d6d89cbSBharata B Rao
3178d6d89cbSBharata B Rao /*
318d5cf4079SPrasanna Kumar Kalever * file=gluster[+transport]://[host[:port]]/volume/path[?socket=...]
3198d6d89cbSBharata B Rao *
3208d6d89cbSBharata B Rao * 'gluster' is the protocol.
3218d6d89cbSBharata B Rao *
3228d6d89cbSBharata B Rao * 'transport' specifies the transport type used to connect to gluster
3238d6d89cbSBharata B Rao * management daemon (glusterd). Valid transport types are
3240552ff24SPrasanna Kumar Kalever * tcp or unix. If a transport type isn't specified, then tcp type is assumed.
3258d6d89cbSBharata B Rao *
326d5cf4079SPrasanna Kumar Kalever * 'host' specifies the host where the volume file specification for
3270552ff24SPrasanna Kumar Kalever * the given volume resides. This can be either hostname or ipv4 address.
328d5cf4079SPrasanna Kumar Kalever * If transport type is 'unix', then 'host' field should not be specified.
3298d6d89cbSBharata B Rao * The 'socket' field needs to be populated with the path to unix domain
3308d6d89cbSBharata B Rao * socket.
3318d6d89cbSBharata B Rao *
3328d6d89cbSBharata B Rao * 'port' is the port number on which glusterd is listening. This is optional
3338d6d89cbSBharata B Rao * and if not specified, QEMU will send 0 which will make gluster to use the
3348d6d89cbSBharata B Rao * default port. If the transport type is unix, then 'port' should not be
3358d6d89cbSBharata B Rao * specified.
3368d6d89cbSBharata B Rao *
337d5cf4079SPrasanna Kumar Kalever * 'volume' is the name of the gluster volume which contains the VM image.
3388d6d89cbSBharata B Rao *
339d5cf4079SPrasanna Kumar Kalever * 'path' is the path to the actual VM image that resides on gluster volume.
3408d6d89cbSBharata B Rao *
3418d6d89cbSBharata B Rao * Examples:
3428d6d89cbSBharata B Rao *
3438d6d89cbSBharata B Rao * file=gluster://1.2.3.4/testvol/a.img
3448d6d89cbSBharata B Rao * file=gluster+tcp://1.2.3.4/testvol/a.img
3458d6d89cbSBharata B Rao * file=gluster+tcp://1.2.3.4:24007/testvol/dir/a.img
346d5cf4079SPrasanna Kumar Kalever * file=gluster+tcp://host.domain.com:24007/testvol/dir/a.img
3478d6d89cbSBharata B Rao * file=gluster+unix:///testvol/dir/a.img?socket=/tmp/glusterd.socket
3488d6d89cbSBharata B Rao */
qemu_gluster_parse_uri(BlockdevOptionsGluster * gconf,const char * filename)3497edac2ddSPrasanna Kumar Kalever static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf,
3507edac2ddSPrasanna Kumar Kalever const char *filename)
3518d6d89cbSBharata B Rao {
35262cf396bSMarkus Armbruster SocketAddress *gsconf;
3538d6d89cbSBharata B Rao URI *uri;
3548d6d89cbSBharata B Rao QueryParams *qp = NULL;
3558d6d89cbSBharata B Rao bool is_unix = false;
3568d6d89cbSBharata B Rao int ret = 0;
3578d6d89cbSBharata B Rao
3588d6d89cbSBharata B Rao uri = uri_parse(filename);
3598d6d89cbSBharata B Rao if (!uri) {
3608d6d89cbSBharata B Rao return -EINVAL;
3618d6d89cbSBharata B Rao }
3628d6d89cbSBharata B Rao
36354aa3de7SEric Blake gsconf = g_new0(SocketAddress, 1);
36454aa3de7SEric Blake QAPI_LIST_PREPEND(gconf->server, gsconf);
3657edac2ddSPrasanna Kumar Kalever
3668d6d89cbSBharata B Rao /* transport */
36724897a76SPaolo Bonzini if (!uri->scheme || !strcmp(uri->scheme, "gluster")) {
36862cf396bSMarkus Armbruster gsconf->type = SOCKET_ADDRESS_TYPE_INET;
3698d6d89cbSBharata B Rao } else if (!strcmp(uri->scheme, "gluster+tcp")) {
37062cf396bSMarkus Armbruster gsconf->type = SOCKET_ADDRESS_TYPE_INET;
3718d6d89cbSBharata B Rao } else if (!strcmp(uri->scheme, "gluster+unix")) {
37262cf396bSMarkus Armbruster gsconf->type = SOCKET_ADDRESS_TYPE_UNIX;
3738d6d89cbSBharata B Rao is_unix = true;
3748d6d89cbSBharata B Rao } else {
3758d6d89cbSBharata B Rao ret = -EINVAL;
3768d6d89cbSBharata B Rao goto out;
3778d6d89cbSBharata B Rao }
3788d6d89cbSBharata B Rao
3798d6d89cbSBharata B Rao ret = parse_volume_options(gconf, uri->path);
3808d6d89cbSBharata B Rao if (ret < 0) {
3818d6d89cbSBharata B Rao goto out;
3828d6d89cbSBharata B Rao }
3838d6d89cbSBharata B Rao
3848d6d89cbSBharata B Rao qp = query_params_parse(uri->query);
3858d6d89cbSBharata B Rao if (qp->n > 1 || (is_unix && !qp->n) || (!is_unix && qp->n)) {
3868d6d89cbSBharata B Rao ret = -EINVAL;
3878d6d89cbSBharata B Rao goto out;
3888d6d89cbSBharata B Rao }
3898d6d89cbSBharata B Rao
3908d6d89cbSBharata B Rao if (is_unix) {
3918d6d89cbSBharata B Rao if (uri->server || uri->port) {
3928d6d89cbSBharata B Rao ret = -EINVAL;
3938d6d89cbSBharata B Rao goto out;
3948d6d89cbSBharata B Rao }
3958d6d89cbSBharata B Rao if (strcmp(qp->p[0].name, "socket")) {
3968d6d89cbSBharata B Rao ret = -EINVAL;
3978d6d89cbSBharata B Rao goto out;
3988d6d89cbSBharata B Rao }
3997edac2ddSPrasanna Kumar Kalever gsconf->u.q_unix.path = g_strdup(qp->p[0].value);
4008d6d89cbSBharata B Rao } else {
401c5f1ae3aSMarkus Armbruster gsconf->u.inet.host = g_strdup(uri->server ? uri->server : "localhost");
4027edac2ddSPrasanna Kumar Kalever if (uri->port) {
403c5f1ae3aSMarkus Armbruster gsconf->u.inet.port = g_strdup_printf("%d", uri->port);
4047edac2ddSPrasanna Kumar Kalever } else {
405c5f1ae3aSMarkus Armbruster gsconf->u.inet.port = g_strdup_printf("%d", GLUSTER_DEFAULT_PORT);
4067edac2ddSPrasanna Kumar Kalever }
4078d6d89cbSBharata B Rao }
4088d6d89cbSBharata B Rao
4098d6d89cbSBharata B Rao out:
4108d6d89cbSBharata B Rao if (qp) {
4118d6d89cbSBharata B Rao query_params_free(qp);
4128d6d89cbSBharata B Rao }
4138d6d89cbSBharata B Rao uri_free(uri);
4148d6d89cbSBharata B Rao return ret;
4158d6d89cbSBharata B Rao }
4168d6d89cbSBharata B Rao
qemu_gluster_glfs_init(BlockdevOptionsGluster * gconf,Error ** errp)4176c7189bbSPrasanna Kumar Kalever static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
4186c7189bbSPrasanna Kumar Kalever Error **errp)
4198d6d89cbSBharata B Rao {
4206c7189bbSPrasanna Kumar Kalever struct glfs *glfs;
4218d6d89cbSBharata B Rao int ret;
4228d6d89cbSBharata B Rao int old_errno;
42362cf396bSMarkus Armbruster SocketAddressList *server;
424bd1386ccSEric Blake uint64_t port;
4258d6d89cbSBharata B Rao
4266349c154SPrasanna Kumar Kalever glfs = glfs_find_preopened(gconf->volume);
4276349c154SPrasanna Kumar Kalever if (glfs) {
4286349c154SPrasanna Kumar Kalever return glfs;
4296349c154SPrasanna Kumar Kalever }
4306349c154SPrasanna Kumar Kalever
431d5cf4079SPrasanna Kumar Kalever glfs = glfs_new(gconf->volume);
4328d6d89cbSBharata B Rao if (!glfs) {
4338d6d89cbSBharata B Rao goto out;
4348d6d89cbSBharata B Rao }
4358d6d89cbSBharata B Rao
4366349c154SPrasanna Kumar Kalever glfs_set_preopened(gconf->volume, glfs);
4376349c154SPrasanna Kumar Kalever
4386c7189bbSPrasanna Kumar Kalever for (server = gconf->server; server; server = server->next) {
439fce5d538SMarkus Armbruster switch (server->value->type) {
44062cf396bSMarkus Armbruster case SOCKET_ADDRESS_TYPE_UNIX:
441fc29458dSMarkus Armbruster ret = glfs_set_volfile_server(glfs, "unix",
4426c7189bbSPrasanna Kumar Kalever server->value->u.q_unix.path, 0);
443fce5d538SMarkus Armbruster break;
44462cf396bSMarkus Armbruster case SOCKET_ADDRESS_TYPE_INET:
445bd1386ccSEric Blake if (parse_uint_full(server->value->u.inet.port, 10, &port) < 0 ||
446c56ac33bSPrasanna Kumar Kalever port > 65535) {
447c56ac33bSPrasanna Kumar Kalever error_setg(errp, "'%s' is not a valid port number",
448c5f1ae3aSMarkus Armbruster server->value->u.inet.port);
449c56ac33bSPrasanna Kumar Kalever errno = EINVAL;
450c56ac33bSPrasanna Kumar Kalever goto out;
451c56ac33bSPrasanna Kumar Kalever }
452fc29458dSMarkus Armbruster ret = glfs_set_volfile_server(glfs, "tcp",
453c5f1ae3aSMarkus Armbruster server->value->u.inet.host,
454c56ac33bSPrasanna Kumar Kalever (int)port);
455fce5d538SMarkus Armbruster break;
45662cf396bSMarkus Armbruster case SOCKET_ADDRESS_TYPE_VSOCK:
45762cf396bSMarkus Armbruster case SOCKET_ADDRESS_TYPE_FD:
458fce5d538SMarkus Armbruster default:
459fce5d538SMarkus Armbruster abort();
4607edac2ddSPrasanna Kumar Kalever }
4616c7189bbSPrasanna Kumar Kalever
4628d6d89cbSBharata B Rao if (ret < 0) {
4638d6d89cbSBharata B Rao goto out;
4648d6d89cbSBharata B Rao }
4656c7189bbSPrasanna Kumar Kalever }
4668d6d89cbSBharata B Rao
4671a417e46SPrasanna Kumar Kalever ret = glfs_set_logging(glfs, gconf->logfile, gconf->debug);
4688d6d89cbSBharata B Rao if (ret < 0) {
4698d6d89cbSBharata B Rao goto out;
4708d6d89cbSBharata B Rao }
4718d6d89cbSBharata B Rao
4728d6d89cbSBharata B Rao ret = glfs_init(glfs);
4738d6d89cbSBharata B Rao if (ret) {
4746c7189bbSPrasanna Kumar Kalever error_setg(errp, "Gluster connection for volume %s, path %s failed"
4756c7189bbSPrasanna Kumar Kalever " to connect", gconf->volume, gconf->path);
4766c7189bbSPrasanna Kumar Kalever for (server = gconf->server; server; server = server->next) {
47762cf396bSMarkus Armbruster if (server->value->type == SOCKET_ADDRESS_TYPE_UNIX) {
4786c7189bbSPrasanna Kumar Kalever error_append_hint(errp, "hint: failed on socket %s ",
4796c7189bbSPrasanna Kumar Kalever server->value->u.q_unix.path);
4807edac2ddSPrasanna Kumar Kalever } else {
4816c7189bbSPrasanna Kumar Kalever error_append_hint(errp, "hint: failed on host %s and port %s ",
482c5f1ae3aSMarkus Armbruster server->value->u.inet.host,
483c5f1ae3aSMarkus Armbruster server->value->u.inet.port);
4847edac2ddSPrasanna Kumar Kalever }
4856c7189bbSPrasanna Kumar Kalever }
4866c7189bbSPrasanna Kumar Kalever
4876c7189bbSPrasanna Kumar Kalever error_append_hint(errp, "Please refer to gluster logs for more info\n");
4884557117dSPeter Krempa
4894557117dSPeter Krempa /* glfs_init sometimes doesn't set errno although docs suggest that */
4907edac2ddSPrasanna Kumar Kalever if (errno == 0) {
4914557117dSPeter Krempa errno = EINVAL;
4927edac2ddSPrasanna Kumar Kalever }
4934557117dSPeter Krempa
4948d6d89cbSBharata B Rao goto out;
4958d6d89cbSBharata B Rao }
4968d6d89cbSBharata B Rao return glfs;
4978d6d89cbSBharata B Rao
4988d6d89cbSBharata B Rao out:
4998d6d89cbSBharata B Rao if (glfs) {
5008d6d89cbSBharata B Rao old_errno = errno;
5016349c154SPrasanna Kumar Kalever glfs_clear_preopened(glfs);
5028d6d89cbSBharata B Rao errno = old_errno;
5038d6d89cbSBharata B Rao }
5048d6d89cbSBharata B Rao return NULL;
5058d6d89cbSBharata B Rao }
5068d6d89cbSBharata B Rao
5076c7189bbSPrasanna Kumar Kalever /*
5086c7189bbSPrasanna Kumar Kalever * Convert the json formatted command line into qapi.
5096c7189bbSPrasanna Kumar Kalever */
qemu_gluster_parse_json(BlockdevOptionsGluster * gconf,QDict * options,Error ** errp)5106c7189bbSPrasanna Kumar Kalever static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
5116c7189bbSPrasanna Kumar Kalever QDict *options, Error **errp)
5126c7189bbSPrasanna Kumar Kalever {
5136c7189bbSPrasanna Kumar Kalever QemuOpts *opts;
51462cf396bSMarkus Armbruster SocketAddress *gsconf = NULL;
51595b3a8c8SEric Blake SocketAddressList **tail;
5166c7189bbSPrasanna Kumar Kalever QDict *backing_options = NULL;
5176c7189bbSPrasanna Kumar Kalever Error *local_err = NULL;
5186c7189bbSPrasanna Kumar Kalever char *str = NULL;
5196c7189bbSPrasanna Kumar Kalever const char *ptr;
52056faeb9bSPeter Maydell int i, type, num_servers;
5216c7189bbSPrasanna Kumar Kalever
5226c7189bbSPrasanna Kumar Kalever /* create opts info from runtime_json_opts list */
5236c7189bbSPrasanna Kumar Kalever opts = qemu_opts_create(&runtime_json_opts, NULL, 0, &error_abort);
524a5f9b9dfSMarkus Armbruster if (!qemu_opts_absorb_qdict(opts, options, errp)) {
5256c7189bbSPrasanna Kumar Kalever goto out;
5266c7189bbSPrasanna Kumar Kalever }
5276c7189bbSPrasanna Kumar Kalever
5286c7189bbSPrasanna Kumar Kalever num_servers = qdict_array_entries(options, GLUSTER_OPT_SERVER_PATTERN);
5296c7189bbSPrasanna Kumar Kalever if (num_servers < 1) {
5306c7189bbSPrasanna Kumar Kalever error_setg(&local_err, QERR_MISSING_PARAMETER, "server");
5316c7189bbSPrasanna Kumar Kalever goto out;
5326c7189bbSPrasanna Kumar Kalever }
5336c7189bbSPrasanna Kumar Kalever
5346c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_VOLUME);
5356c7189bbSPrasanna Kumar Kalever if (!ptr) {
5366c7189bbSPrasanna Kumar Kalever error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_VOLUME);
5376c7189bbSPrasanna Kumar Kalever goto out;
5386c7189bbSPrasanna Kumar Kalever }
5396c7189bbSPrasanna Kumar Kalever gconf->volume = g_strdup(ptr);
5406c7189bbSPrasanna Kumar Kalever
5416c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_PATH);
5426c7189bbSPrasanna Kumar Kalever if (!ptr) {
5436c7189bbSPrasanna Kumar Kalever error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_PATH);
5446c7189bbSPrasanna Kumar Kalever goto out;
5456c7189bbSPrasanna Kumar Kalever }
5466c7189bbSPrasanna Kumar Kalever gconf->path = g_strdup(ptr);
5476c7189bbSPrasanna Kumar Kalever qemu_opts_del(opts);
54895b3a8c8SEric Blake tail = &gconf->server;
5496c7189bbSPrasanna Kumar Kalever
5506c7189bbSPrasanna Kumar Kalever for (i = 0; i < num_servers; i++) {
5516c7189bbSPrasanna Kumar Kalever str = g_strdup_printf(GLUSTER_OPT_SERVER_PATTERN"%d.", i);
5526c7189bbSPrasanna Kumar Kalever qdict_extract_subqdict(options, &backing_options, str);
5536c7189bbSPrasanna Kumar Kalever
5546c7189bbSPrasanna Kumar Kalever /* create opts info from runtime_type_opts list */
5556c7189bbSPrasanna Kumar Kalever opts = qemu_opts_create(&runtime_type_opts, NULL, 0, &error_abort);
556a5f9b9dfSMarkus Armbruster if (!qemu_opts_absorb_qdict(opts, backing_options, errp)) {
5576c7189bbSPrasanna Kumar Kalever goto out;
5586c7189bbSPrasanna Kumar Kalever }
5596c7189bbSPrasanna Kumar Kalever
5606c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_TYPE);
5616c7189bbSPrasanna Kumar Kalever if (!ptr) {
5626c7189bbSPrasanna Kumar Kalever error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_TYPE);
5636c7189bbSPrasanna Kumar Kalever error_append_hint(&local_err, GERR_INDEX_HINT, i);
5646c7189bbSPrasanna Kumar Kalever goto out;
5656c7189bbSPrasanna Kumar Kalever
5666c7189bbSPrasanna Kumar Kalever }
56762cf396bSMarkus Armbruster gsconf = g_new0(SocketAddress, 1);
568c5f1ae3aSMarkus Armbruster if (!strcmp(ptr, "tcp")) {
569c5f1ae3aSMarkus Armbruster ptr = "inet"; /* accept legacy "tcp" */
570c5f1ae3aSMarkus Armbruster }
571f7abe0ecSMarc-André Lureau type = qapi_enum_parse(&SocketAddressType_lookup, ptr, -1, NULL);
57262cf396bSMarkus Armbruster if (type != SOCKET_ADDRESS_TYPE_INET
57362cf396bSMarkus Armbruster && type != SOCKET_ADDRESS_TYPE_UNIX) {
574fce5d538SMarkus Armbruster error_setg(&local_err,
575fce5d538SMarkus Armbruster "Parameter '%s' may be 'inet' or 'unix'",
576e152ef7aSMarkus Armbruster GLUSTER_OPT_TYPE);
5776c7189bbSPrasanna Kumar Kalever error_append_hint(&local_err, GERR_INDEX_HINT, i);
5786c7189bbSPrasanna Kumar Kalever goto out;
5796c7189bbSPrasanna Kumar Kalever }
580fce5d538SMarkus Armbruster gsconf->type = type;
5816c7189bbSPrasanna Kumar Kalever qemu_opts_del(opts);
5826c7189bbSPrasanna Kumar Kalever
58362cf396bSMarkus Armbruster if (gsconf->type == SOCKET_ADDRESS_TYPE_INET) {
584c5f1ae3aSMarkus Armbruster /* create opts info from runtime_inet_opts list */
585c5f1ae3aSMarkus Armbruster opts = qemu_opts_create(&runtime_inet_opts, NULL, 0, &error_abort);
586a5f9b9dfSMarkus Armbruster if (!qemu_opts_absorb_qdict(opts, backing_options, errp)) {
5876c7189bbSPrasanna Kumar Kalever goto out;
5886c7189bbSPrasanna Kumar Kalever }
5896c7189bbSPrasanna Kumar Kalever
5906c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_HOST);
5916c7189bbSPrasanna Kumar Kalever if (!ptr) {
5926c7189bbSPrasanna Kumar Kalever error_setg(&local_err, QERR_MISSING_PARAMETER,
5936c7189bbSPrasanna Kumar Kalever GLUSTER_OPT_HOST);
5946c7189bbSPrasanna Kumar Kalever error_append_hint(&local_err, GERR_INDEX_HINT, i);
5956c7189bbSPrasanna Kumar Kalever goto out;
5966c7189bbSPrasanna Kumar Kalever }
597c5f1ae3aSMarkus Armbruster gsconf->u.inet.host = g_strdup(ptr);
5986c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_PORT);
5996c7189bbSPrasanna Kumar Kalever if (!ptr) {
6006c7189bbSPrasanna Kumar Kalever error_setg(&local_err, QERR_MISSING_PARAMETER,
6016c7189bbSPrasanna Kumar Kalever GLUSTER_OPT_PORT);
6026c7189bbSPrasanna Kumar Kalever error_append_hint(&local_err, GERR_INDEX_HINT, i);
6036c7189bbSPrasanna Kumar Kalever goto out;
6046c7189bbSPrasanna Kumar Kalever }
605c5f1ae3aSMarkus Armbruster gsconf->u.inet.port = g_strdup(ptr);
6066c7189bbSPrasanna Kumar Kalever
6076c7189bbSPrasanna Kumar Kalever /* defend for unsupported fields in InetSocketAddress,
6086c7189bbSPrasanna Kumar Kalever * i.e. @ipv4, @ipv6 and @to
6096c7189bbSPrasanna Kumar Kalever */
6106c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_TO);
6116c7189bbSPrasanna Kumar Kalever if (ptr) {
612c5f1ae3aSMarkus Armbruster gsconf->u.inet.has_to = true;
6136c7189bbSPrasanna Kumar Kalever }
6146c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV4);
6156c7189bbSPrasanna Kumar Kalever if (ptr) {
616c5f1ae3aSMarkus Armbruster gsconf->u.inet.has_ipv4 = true;
6176c7189bbSPrasanna Kumar Kalever }
6186c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV6);
6196c7189bbSPrasanna Kumar Kalever if (ptr) {
620c5f1ae3aSMarkus Armbruster gsconf->u.inet.has_ipv6 = true;
6216c7189bbSPrasanna Kumar Kalever }
622c5f1ae3aSMarkus Armbruster if (gsconf->u.inet.has_to) {
6236c7189bbSPrasanna Kumar Kalever error_setg(&local_err, "Parameter 'to' not supported");
6246c7189bbSPrasanna Kumar Kalever goto out;
6256c7189bbSPrasanna Kumar Kalever }
626c5f1ae3aSMarkus Armbruster if (gsconf->u.inet.has_ipv4 || gsconf->u.inet.has_ipv6) {
6276c7189bbSPrasanna Kumar Kalever error_setg(&local_err, "Parameters 'ipv4/ipv6' not supported");
6286c7189bbSPrasanna Kumar Kalever goto out;
6296c7189bbSPrasanna Kumar Kalever }
6306c7189bbSPrasanna Kumar Kalever qemu_opts_del(opts);
6316c7189bbSPrasanna Kumar Kalever } else {
6326c7189bbSPrasanna Kumar Kalever /* create opts info from runtime_unix_opts list */
6336c7189bbSPrasanna Kumar Kalever opts = qemu_opts_create(&runtime_unix_opts, NULL, 0, &error_abort);
634a5f9b9dfSMarkus Armbruster if (!qemu_opts_absorb_qdict(opts, backing_options, errp)) {
6356c7189bbSPrasanna Kumar Kalever goto out;
6366c7189bbSPrasanna Kumar Kalever }
6376c7189bbSPrasanna Kumar Kalever
6389dae635aSKevin Wolf ptr = qemu_opt_get(opts, GLUSTER_OPT_PATH);
6399dae635aSKevin Wolf if (!ptr) {
6406c7189bbSPrasanna Kumar Kalever ptr = qemu_opt_get(opts, GLUSTER_OPT_SOCKET);
6419dae635aSKevin Wolf } else if (qemu_opt_get(opts, GLUSTER_OPT_SOCKET)) {
6429dae635aSKevin Wolf error_setg(&local_err,
6439dae635aSKevin Wolf "Conflicting parameters 'path' and 'socket'");
6449dae635aSKevin Wolf error_append_hint(&local_err, GERR_INDEX_HINT, i);
6459dae635aSKevin Wolf goto out;
6469dae635aSKevin Wolf }
6476c7189bbSPrasanna Kumar Kalever if (!ptr) {
6486c7189bbSPrasanna Kumar Kalever error_setg(&local_err, QERR_MISSING_PARAMETER,
6499dae635aSKevin Wolf GLUSTER_OPT_PATH);
6506c7189bbSPrasanna Kumar Kalever error_append_hint(&local_err, GERR_INDEX_HINT, i);
6516c7189bbSPrasanna Kumar Kalever goto out;
6526c7189bbSPrasanna Kumar Kalever }
6536c7189bbSPrasanna Kumar Kalever gsconf->u.q_unix.path = g_strdup(ptr);
6546c7189bbSPrasanna Kumar Kalever qemu_opts_del(opts);
6556c7189bbSPrasanna Kumar Kalever }
6566c7189bbSPrasanna Kumar Kalever
65795b3a8c8SEric Blake QAPI_LIST_APPEND(tail, gsconf);
65885a82e85SMarkus Armbruster gsconf = NULL;
6596c7189bbSPrasanna Kumar Kalever
660cb3e7f08SMarc-André Lureau qobject_unref(backing_options);
66185a82e85SMarkus Armbruster backing_options = NULL;
6626c7189bbSPrasanna Kumar Kalever g_free(str);
6636c7189bbSPrasanna Kumar Kalever str = NULL;
6646c7189bbSPrasanna Kumar Kalever }
6656c7189bbSPrasanna Kumar Kalever
6666c7189bbSPrasanna Kumar Kalever return 0;
6676c7189bbSPrasanna Kumar Kalever
6686c7189bbSPrasanna Kumar Kalever out:
6696c7189bbSPrasanna Kumar Kalever error_propagate(errp, local_err);
67062cf396bSMarkus Armbruster qapi_free_SocketAddress(gsconf);
6716c7189bbSPrasanna Kumar Kalever qemu_opts_del(opts);
6726c7189bbSPrasanna Kumar Kalever g_free(str);
673cb3e7f08SMarc-André Lureau qobject_unref(backing_options);
6746c7189bbSPrasanna Kumar Kalever errno = EINVAL;
6756c7189bbSPrasanna Kumar Kalever return -errno;
6766c7189bbSPrasanna Kumar Kalever }
6776c7189bbSPrasanna Kumar Kalever
678ab8bda76SKevin Wolf /* Converts options given in @filename and the @options QDict into the QAPI
679ab8bda76SKevin Wolf * object @gconf. */
qemu_gluster_parse(BlockdevOptionsGluster * gconf,const char * filename,QDict * options,Error ** errp)680ab8bda76SKevin Wolf static int qemu_gluster_parse(BlockdevOptionsGluster *gconf,
6816c7189bbSPrasanna Kumar Kalever const char *filename,
6826c7189bbSPrasanna Kumar Kalever QDict *options, Error **errp)
6836c7189bbSPrasanna Kumar Kalever {
6846c7189bbSPrasanna Kumar Kalever int ret;
6856c7189bbSPrasanna Kumar Kalever if (filename) {
6866c7189bbSPrasanna Kumar Kalever ret = qemu_gluster_parse_uri(gconf, filename);
6876c7189bbSPrasanna Kumar Kalever if (ret < 0) {
68844acd46fSDaniel P. Berrangé error_setg(errp, "invalid URI %s", filename);
6896c7189bbSPrasanna Kumar Kalever error_append_hint(errp, "Usage: file=gluster[+transport]://"
690e9db8ff3SPrasanna Kumar Kalever "[host[:port]]volume/path[?socket=...]"
691e9db8ff3SPrasanna Kumar Kalever "[,file.debug=N]"
692e9db8ff3SPrasanna Kumar Kalever "[,file.logfile=/path/filename.log]\n");
693ab8bda76SKevin Wolf return ret;
6946c7189bbSPrasanna Kumar Kalever }
6956c7189bbSPrasanna Kumar Kalever } else {
6966c7189bbSPrasanna Kumar Kalever ret = qemu_gluster_parse_json(gconf, options, errp);
6976c7189bbSPrasanna Kumar Kalever if (ret < 0) {
6986c7189bbSPrasanna Kumar Kalever error_append_hint(errp, "Usage: "
6996c7189bbSPrasanna Kumar Kalever "-drive driver=qcow2,file.driver=gluster,"
7006c7189bbSPrasanna Kumar Kalever "file.volume=testvol,file.path=/path/a.qcow2"
701e9db8ff3SPrasanna Kumar Kalever "[,file.debug=9]"
702e9db8ff3SPrasanna Kumar Kalever "[,file.logfile=/path/filename.log],"
703c5f1ae3aSMarkus Armbruster "file.server.0.type=inet,"
7046c7189bbSPrasanna Kumar Kalever "file.server.0.host=1.2.3.4,"
7056c7189bbSPrasanna Kumar Kalever "file.server.0.port=24007,"
7066c7189bbSPrasanna Kumar Kalever "file.server.1.transport=unix,"
7079dae635aSKevin Wolf "file.server.1.path=/var/run/glusterd.socket ..."
7086c7189bbSPrasanna Kumar Kalever "\n");
709ab8bda76SKevin Wolf return ret;
710ab8bda76SKevin Wolf }
7116c7189bbSPrasanna Kumar Kalever }
7126c7189bbSPrasanna Kumar Kalever
713ab8bda76SKevin Wolf return 0;
714ab8bda76SKevin Wolf }
715ab8bda76SKevin Wolf
qemu_gluster_init(BlockdevOptionsGluster * gconf,const char * filename,QDict * options,Error ** errp)716ab8bda76SKevin Wolf static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf,
717ab8bda76SKevin Wolf const char *filename,
718ab8bda76SKevin Wolf QDict *options, Error **errp)
719ab8bda76SKevin Wolf {
720ab8bda76SKevin Wolf int ret;
721ab8bda76SKevin Wolf
722ab8bda76SKevin Wolf ret = qemu_gluster_parse(gconf, filename, options, errp);
723ab8bda76SKevin Wolf if (ret < 0) {
724ab8bda76SKevin Wolf errno = -ret;
725ab8bda76SKevin Wolf return NULL;
7266c7189bbSPrasanna Kumar Kalever }
7276c7189bbSPrasanna Kumar Kalever
7286c7189bbSPrasanna Kumar Kalever return qemu_gluster_glfs_init(gconf, errp);
7296c7189bbSPrasanna Kumar Kalever }
7306c7189bbSPrasanna Kumar Kalever
7317c815372SBharata B Rao /*
7327c815372SBharata B Rao * AIO callback routine called from GlusterFS thread.
7337c815372SBharata B Rao */
gluster_finish_aiocb(struct glfs_fd * fd,ssize_t ret,struct glfs_stat * pre,struct glfs_stat * post,void * arg)7340e3b891fSNiels de Vos static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret,
7350e3b891fSNiels de Vos #ifdef CONFIG_GLUSTERFS_IOCB_HAS_STAT
7360e3b891fSNiels de Vos struct glfs_stat *pre, struct glfs_stat *post,
7370e3b891fSNiels de Vos #endif
7380e3b891fSNiels de Vos void *arg)
7397c815372SBharata B Rao {
7407c815372SBharata B Rao GlusterAIOCB *acb = (GlusterAIOCB *)arg;
7417c815372SBharata B Rao
7427c815372SBharata B Rao if (!ret || ret == acb->size) {
7437c815372SBharata B Rao acb->ret = 0; /* Success */
7447c815372SBharata B Rao } else if (ret < 0) {
745a8827453SJeff Cody acb->ret = -errno; /* Read/Write failed */
7467c815372SBharata B Rao } else {
7477c815372SBharata B Rao acb->ret = -EIO; /* Partial read/write - fail it */
7487c815372SBharata B Rao }
7497c815372SBharata B Rao
7501919631eSPaolo Bonzini aio_co_schedule(acb->aio_context, acb->coroutine);
7517c815372SBharata B Rao }
7527c815372SBharata B Rao
qemu_gluster_parse_flags(int bdrv_flags,int * open_flags)7531b37b344SJeff Cody static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags)
7541b37b344SJeff Cody {
7551b37b344SJeff Cody assert(open_flags != NULL);
7561b37b344SJeff Cody
7571b37b344SJeff Cody *open_flags |= O_BINARY;
7581b37b344SJeff Cody
7591b37b344SJeff Cody if (bdrv_flags & BDRV_O_RDWR) {
7601b37b344SJeff Cody *open_flags |= O_RDWR;
7611b37b344SJeff Cody } else {
7621b37b344SJeff Cody *open_flags |= O_RDONLY;
7631b37b344SJeff Cody }
7641b37b344SJeff Cody
7651b37b344SJeff Cody if ((bdrv_flags & BDRV_O_NOCACHE)) {
7661b37b344SJeff Cody *open_flags |= O_DIRECT;
7671b37b344SJeff Cody }
7681b37b344SJeff Cody }
7691b37b344SJeff Cody
770947eb203SNiels de Vos /*
771947eb203SNiels de Vos * Do SEEK_DATA/HOLE to detect if it is functional. Older broken versions of
772947eb203SNiels de Vos * gfapi incorrectly return the current offset when SEEK_DATA/HOLE is used.
773947eb203SNiels de Vos * - Corrected versions return -1 and set errno to EINVAL.
774947eb203SNiels de Vos * - Versions that support SEEK_DATA/HOLE correctly, will return -1 and set
775947eb203SNiels de Vos * errno to ENXIO when SEEK_DATA is called with a position of EOF.
776947eb203SNiels de Vos */
qemu_gluster_test_seek(struct glfs_fd * fd)777947eb203SNiels de Vos static bool qemu_gluster_test_seek(struct glfs_fd *fd)
778947eb203SNiels de Vos {
779d9b78974SJeff Cody off_t ret = 0;
780d9b78974SJeff Cody
781d9b78974SJeff Cody #if defined SEEK_HOLE && defined SEEK_DATA
782d9b78974SJeff Cody off_t eof;
783947eb203SNiels de Vos
784947eb203SNiels de Vos eof = glfs_lseek(fd, 0, SEEK_END);
785947eb203SNiels de Vos if (eof < 0) {
786947eb203SNiels de Vos /* this should never occur */
787947eb203SNiels de Vos return false;
788947eb203SNiels de Vos }
789947eb203SNiels de Vos
790947eb203SNiels de Vos /* this should always fail with ENXIO if SEEK_DATA is supported */
791947eb203SNiels de Vos ret = glfs_lseek(fd, eof, SEEK_DATA);
792d9b78974SJeff Cody #endif
793d9b78974SJeff Cody
794947eb203SNiels de Vos return (ret < 0) && (errno == ENXIO);
795947eb203SNiels de Vos }
796947eb203SNiels de Vos
qemu_gluster_open(BlockDriverState * bs,QDict * options,int bdrv_flags,Error ** errp)79756d1b4d2SKevin Wolf static int qemu_gluster_open(BlockDriverState *bs, QDict *options,
798015a1036SMax Reitz int bdrv_flags, Error **errp)
7998d6d89cbSBharata B Rao {
8008d6d89cbSBharata B Rao BDRVGlusterState *s = bs->opaque;
8011b37b344SJeff Cody int open_flags = 0;
8028d6d89cbSBharata B Rao int ret = 0;
8037edac2ddSPrasanna Kumar Kalever BlockdevOptionsGluster *gconf = NULL;
804b4894776SKevin Wolf QemuOpts *opts;
805e9db8ff3SPrasanna Kumar Kalever const char *filename, *logfile;
806b4894776SKevin Wolf
80787ea75d5SPeter Crosthwaite opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
808af175e85SMarkus Armbruster if (!qemu_opts_absorb_qdict(opts, options, errp)) {
809b4894776SKevin Wolf ret = -EINVAL;
810b4894776SKevin Wolf goto out;
811b4894776SKevin Wolf }
812b4894776SKevin Wolf
8137eac868aSJeff Cody filename = qemu_opt_get(opts, GLUSTER_OPT_FILENAME);
814b4894776SKevin Wolf
8151a417e46SPrasanna Kumar Kalever s->debug = qemu_opt_get_number(opts, GLUSTER_OPT_DEBUG,
8167eac868aSJeff Cody GLUSTER_DEBUG_DEFAULT);
8171a417e46SPrasanna Kumar Kalever if (s->debug < 0) {
8181a417e46SPrasanna Kumar Kalever s->debug = 0;
8191a417e46SPrasanna Kumar Kalever } else if (s->debug > GLUSTER_DEBUG_MAX) {
8201a417e46SPrasanna Kumar Kalever s->debug = GLUSTER_DEBUG_MAX;
8217eac868aSJeff Cody }
8227eac868aSJeff Cody
8237edac2ddSPrasanna Kumar Kalever gconf = g_new0(BlockdevOptionsGluster, 1);
8241a417e46SPrasanna Kumar Kalever gconf->debug = s->debug;
8251a417e46SPrasanna Kumar Kalever gconf->has_debug = true;
826e9db8ff3SPrasanna Kumar Kalever
827e9db8ff3SPrasanna Kumar Kalever logfile = qemu_opt_get(opts, GLUSTER_OPT_LOGFILE);
828e9db8ff3SPrasanna Kumar Kalever s->logfile = g_strdup(logfile ? logfile : GLUSTER_LOGFILE_DEFAULT);
829e9db8ff3SPrasanna Kumar Kalever
830e9db8ff3SPrasanna Kumar Kalever gconf->logfile = g_strdup(s->logfile);
831e9db8ff3SPrasanna Kumar Kalever
8326c7189bbSPrasanna Kumar Kalever s->glfs = qemu_gluster_init(gconf, filename, options, errp);
8338d6d89cbSBharata B Rao if (!s->glfs) {
8348d6d89cbSBharata B Rao ret = -errno;
8358d6d89cbSBharata B Rao goto out;
8368d6d89cbSBharata B Rao }
8378d6d89cbSBharata B Rao
838d85fa9ebSJeff Cody #ifdef CONFIG_GLUSTERFS_XLATOR_OPT
839d85fa9ebSJeff Cody /* Without this, if fsync fails for a recoverable reason (for instance,
840d85fa9ebSJeff Cody * ENOSPC), gluster will dump its cache, preventing retries. This means
841d85fa9ebSJeff Cody * almost certain data loss. Not all gluster versions support the
842d85fa9ebSJeff Cody * 'resync-failed-syncs-after-fsync' key value, but there is no way to
843d85fa9ebSJeff Cody * discover during runtime if it is supported (this api returns success for
844d85fa9ebSJeff Cody * unknown key/value pairs) */
845d85fa9ebSJeff Cody ret = glfs_set_xlator_option(s->glfs, "*-write-behind",
846d85fa9ebSJeff Cody "resync-failed-syncs-after-fsync",
847d85fa9ebSJeff Cody "on");
848d85fa9ebSJeff Cody if (ret < 0) {
849d85fa9ebSJeff Cody error_setg_errno(errp, errno, "Unable to set xlator key/value pair");
850d85fa9ebSJeff Cody ret = -errno;
851d85fa9ebSJeff Cody goto out;
852d85fa9ebSJeff Cody }
853d85fa9ebSJeff Cody #endif
854d85fa9ebSJeff Cody
8551b37b344SJeff Cody qemu_gluster_parse_flags(bdrv_flags, &open_flags);
8568d6d89cbSBharata B Rao
857d5cf4079SPrasanna Kumar Kalever s->fd = glfs_open(s->glfs, gconf->path, open_flags);
85854ea21bdSKevin Wolf ret = s->fd ? 0 : -errno;
85954ea21bdSKevin Wolf
86054ea21bdSKevin Wolf if (ret == -EACCES || ret == -EROFS) {
86154ea21bdSKevin Wolf /* Try to degrade to read-only, but if it doesn't work, still use the
86254ea21bdSKevin Wolf * normal error message. */
863018f9deaSKevin Wolf bdrv_graph_rdlock_main_loop();
86454ea21bdSKevin Wolf if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) {
86554ea21bdSKevin Wolf open_flags = (open_flags & ~O_RDWR) | O_RDONLY;
86654ea21bdSKevin Wolf s->fd = glfs_open(s->glfs, gconf->path, open_flags);
86754ea21bdSKevin Wolf ret = s->fd ? 0 : -errno;
86854ea21bdSKevin Wolf }
869018f9deaSKevin Wolf bdrv_graph_rdunlock_main_loop();
8708d6d89cbSBharata B Rao }
8718d6d89cbSBharata B Rao
872947eb203SNiels de Vos s->supports_seek_data = qemu_gluster_test_seek(s->fd);
873947eb203SNiels de Vos
8748d6d89cbSBharata B Rao out:
875b4894776SKevin Wolf qemu_opts_del(opts);
8767edac2ddSPrasanna Kumar Kalever qapi_free_BlockdevOptionsGluster(gconf);
8778d6d89cbSBharata B Rao if (!ret) {
8788d6d89cbSBharata B Rao return ret;
8798d6d89cbSBharata B Rao }
880e9db8ff3SPrasanna Kumar Kalever g_free(s->logfile);
8818d6d89cbSBharata B Rao if (s->fd) {
8828d6d89cbSBharata B Rao glfs_close(s->fd);
8838d6d89cbSBharata B Rao }
8846349c154SPrasanna Kumar Kalever
8856349c154SPrasanna Kumar Kalever glfs_clear_preopened(s->glfs);
8866349c154SPrasanna Kumar Kalever
8878d6d89cbSBharata B Rao return ret;
8888d6d89cbSBharata B Rao }
8898d6d89cbSBharata B Rao
qemu_gluster_refresh_limits(BlockDriverState * bs,Error ** errp)890de23e72bSStefano Garzarella static void qemu_gluster_refresh_limits(BlockDriverState *bs, Error **errp)
891de23e72bSStefano Garzarella {
892de23e72bSStefano Garzarella bs->bl.max_transfer = GLUSTER_MAX_TRANSFER;
8939b38fc56SFabian Ebner bs->bl.max_pdiscard = MIN(SIZE_MAX, INT64_MAX);
894de23e72bSStefano Garzarella }
895de23e72bSStefano Garzarella
qemu_gluster_reopen_prepare(BDRVReopenState * state,BlockReopenQueue * queue,Error ** errp)896adccfbcdSJeff Cody static int qemu_gluster_reopen_prepare(BDRVReopenState *state,
897adccfbcdSJeff Cody BlockReopenQueue *queue, Error **errp)
898adccfbcdSJeff Cody {
899adccfbcdSJeff Cody int ret = 0;
9007eac868aSJeff Cody BDRVGlusterState *s;
901adccfbcdSJeff Cody BDRVGlusterReopenState *reop_s;
9027edac2ddSPrasanna Kumar Kalever BlockdevOptionsGluster *gconf;
903adccfbcdSJeff Cody int open_flags = 0;
904adccfbcdSJeff Cody
905adccfbcdSJeff Cody assert(state != NULL);
906adccfbcdSJeff Cody assert(state->bs != NULL);
907adccfbcdSJeff Cody
9087eac868aSJeff Cody s = state->bs->opaque;
9097eac868aSJeff Cody
9105839e53bSMarkus Armbruster state->opaque = g_new0(BDRVGlusterReopenState, 1);
911adccfbcdSJeff Cody reop_s = state->opaque;
912adccfbcdSJeff Cody
913adccfbcdSJeff Cody qemu_gluster_parse_flags(state->flags, &open_flags);
914adccfbcdSJeff Cody
9157edac2ddSPrasanna Kumar Kalever gconf = g_new0(BlockdevOptionsGluster, 1);
9161a417e46SPrasanna Kumar Kalever gconf->debug = s->debug;
9171a417e46SPrasanna Kumar Kalever gconf->has_debug = true;
918e9db8ff3SPrasanna Kumar Kalever gconf->logfile = g_strdup(s->logfile);
9190b1847bbSStefano Garzarella
9200b1847bbSStefano Garzarella /*
9210b1847bbSStefano Garzarella * If 'state->bs->exact_filename' is empty, 'state->options' should contain
9220b1847bbSStefano Garzarella * the JSON parameters already parsed.
9230b1847bbSStefano Garzarella */
9240b1847bbSStefano Garzarella if (state->bs->exact_filename[0] != '\0') {
9250b1847bbSStefano Garzarella reop_s->glfs = qemu_gluster_init(gconf, state->bs->exact_filename, NULL,
9260b1847bbSStefano Garzarella errp);
9270b1847bbSStefano Garzarella } else {
9280b1847bbSStefano Garzarella reop_s->glfs = qemu_gluster_init(gconf, NULL, state->options, errp);
9290b1847bbSStefano Garzarella }
930adccfbcdSJeff Cody if (reop_s->glfs == NULL) {
931adccfbcdSJeff Cody ret = -errno;
932adccfbcdSJeff Cody goto exit;
933adccfbcdSJeff Cody }
934adccfbcdSJeff Cody
935d85fa9ebSJeff Cody #ifdef CONFIG_GLUSTERFS_XLATOR_OPT
936d85fa9ebSJeff Cody ret = glfs_set_xlator_option(reop_s->glfs, "*-write-behind",
937d85fa9ebSJeff Cody "resync-failed-syncs-after-fsync", "on");
938d85fa9ebSJeff Cody if (ret < 0) {
939d85fa9ebSJeff Cody error_setg_errno(errp, errno, "Unable to set xlator key/value pair");
940d85fa9ebSJeff Cody ret = -errno;
941d85fa9ebSJeff Cody goto exit;
942d85fa9ebSJeff Cody }
943d85fa9ebSJeff Cody #endif
944d85fa9ebSJeff Cody
945d5cf4079SPrasanna Kumar Kalever reop_s->fd = glfs_open(reop_s->glfs, gconf->path, open_flags);
946adccfbcdSJeff Cody if (reop_s->fd == NULL) {
947adccfbcdSJeff Cody /* reops->glfs will be cleaned up in _abort */
948adccfbcdSJeff Cody ret = -errno;
949adccfbcdSJeff Cody goto exit;
950adccfbcdSJeff Cody }
951adccfbcdSJeff Cody
952adccfbcdSJeff Cody exit:
953adccfbcdSJeff Cody /* state->opaque will be freed in either the _abort or _commit */
9547edac2ddSPrasanna Kumar Kalever qapi_free_BlockdevOptionsGluster(gconf);
955adccfbcdSJeff Cody return ret;
956adccfbcdSJeff Cody }
957adccfbcdSJeff Cody
qemu_gluster_reopen_commit(BDRVReopenState * state)958adccfbcdSJeff Cody static void qemu_gluster_reopen_commit(BDRVReopenState *state)
959adccfbcdSJeff Cody {
960adccfbcdSJeff Cody BDRVGlusterReopenState *reop_s = state->opaque;
961adccfbcdSJeff Cody BDRVGlusterState *s = state->bs->opaque;
962adccfbcdSJeff Cody
963adccfbcdSJeff Cody
964adccfbcdSJeff Cody /* close the old */
965adccfbcdSJeff Cody if (s->fd) {
966adccfbcdSJeff Cody glfs_close(s->fd);
967adccfbcdSJeff Cody }
9686349c154SPrasanna Kumar Kalever
9696349c154SPrasanna Kumar Kalever glfs_clear_preopened(s->glfs);
970adccfbcdSJeff Cody
971adccfbcdSJeff Cody /* use the newly opened image / connection */
972adccfbcdSJeff Cody s->fd = reop_s->fd;
973adccfbcdSJeff Cody s->glfs = reop_s->glfs;
974adccfbcdSJeff Cody
975adccfbcdSJeff Cody g_free(state->opaque);
976adccfbcdSJeff Cody state->opaque = NULL;
977adccfbcdSJeff Cody
978adccfbcdSJeff Cody return;
979adccfbcdSJeff Cody }
980adccfbcdSJeff Cody
981adccfbcdSJeff Cody
qemu_gluster_reopen_abort(BDRVReopenState * state)982adccfbcdSJeff Cody static void qemu_gluster_reopen_abort(BDRVReopenState *state)
983adccfbcdSJeff Cody {
984adccfbcdSJeff Cody BDRVGlusterReopenState *reop_s = state->opaque;
985adccfbcdSJeff Cody
986adccfbcdSJeff Cody if (reop_s == NULL) {
987adccfbcdSJeff Cody return;
988adccfbcdSJeff Cody }
989adccfbcdSJeff Cody
990adccfbcdSJeff Cody if (reop_s->fd) {
991adccfbcdSJeff Cody glfs_close(reop_s->fd);
992adccfbcdSJeff Cody }
993adccfbcdSJeff Cody
9946349c154SPrasanna Kumar Kalever glfs_clear_preopened(reop_s->glfs);
995adccfbcdSJeff Cody
996adccfbcdSJeff Cody g_free(state->opaque);
997adccfbcdSJeff Cody state->opaque = NULL;
998adccfbcdSJeff Cody
999adccfbcdSJeff Cody return;
1000adccfbcdSJeff Cody }
1001adccfbcdSJeff Cody
10027c815372SBharata B Rao #ifdef CONFIG_GLUSTERFS_ZEROFILL
qemu_gluster_co_pwrite_zeroes(BlockDriverState * bs,int64_t offset,int64_t bytes,BdrvRequestFlags flags)1003e88a36ebSEric Blake static coroutine_fn int qemu_gluster_co_pwrite_zeroes(BlockDriverState *bs,
1004f70c50c8SPrasanna Kumar Kalever int64_t offset,
1005f34b2bcfSVladimir Sementsov-Ogievskiy int64_t bytes,
1006f70c50c8SPrasanna Kumar Kalever BdrvRequestFlags flags)
10077c815372SBharata B Rao {
10087c815372SBharata B Rao int ret;
1009c833d1e8SPaolo Bonzini GlusterAIOCB acb;
10107c815372SBharata B Rao BDRVGlusterState *s = bs->opaque;
10117c815372SBharata B Rao
1012f34b2bcfSVladimir Sementsov-Ogievskiy acb.size = bytes;
1013c833d1e8SPaolo Bonzini acb.ret = 0;
1014c833d1e8SPaolo Bonzini acb.coroutine = qemu_coroutine_self();
1015c833d1e8SPaolo Bonzini acb.aio_context = bdrv_get_aio_context(bs);
10167c815372SBharata B Rao
1017f34b2bcfSVladimir Sementsov-Ogievskiy ret = glfs_zerofill_async(s->fd, offset, bytes, gluster_finish_aiocb, &acb);
10187c815372SBharata B Rao if (ret < 0) {
1019c833d1e8SPaolo Bonzini return -errno;
10207c815372SBharata B Rao }
10217c815372SBharata B Rao
10227c815372SBharata B Rao qemu_coroutine_yield();
1023c833d1e8SPaolo Bonzini return acb.ret;
10247c815372SBharata B Rao }
10257c815372SBharata B Rao #endif
10267c815372SBharata B Rao
qemu_gluster_do_truncate(struct glfs_fd * fd,int64_t offset,PreallocMode prealloc,Error ** errp)102736e87909SMax Reitz static int qemu_gluster_do_truncate(struct glfs_fd *fd, int64_t offset,
102836e87909SMax Reitz PreallocMode prealloc, Error **errp)
102936e87909SMax Reitz {
1030f3a33f79SMax Reitz int64_t current_length;
1031f3a33f79SMax Reitz
1032f3a33f79SMax Reitz current_length = glfs_lseek(fd, 0, SEEK_END);
1033f3a33f79SMax Reitz if (current_length < 0) {
1034f3a33f79SMax Reitz error_setg_errno(errp, errno, "Failed to determine current size");
1035f3a33f79SMax Reitz return -errno;
1036f3a33f79SMax Reitz }
1037f3a33f79SMax Reitz
1038f3a33f79SMax Reitz if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
1039f3a33f79SMax Reitz error_setg(errp, "Cannot use preallocation for shrinking files");
1040f3a33f79SMax Reitz return -ENOTSUP;
1041f3a33f79SMax Reitz }
1042f3a33f79SMax Reitz
1043f3a33f79SMax Reitz if (current_length == offset) {
1044f3a33f79SMax Reitz return 0;
1045f3a33f79SMax Reitz }
1046f3a33f79SMax Reitz
104736e87909SMax Reitz switch (prealloc) {
104836e87909SMax Reitz #ifdef CONFIG_GLUSTERFS_FALLOCATE
104936e87909SMax Reitz case PREALLOC_MODE_FALLOC:
1050f3a33f79SMax Reitz if (glfs_fallocate(fd, 0, current_length, offset - current_length)) {
105136e87909SMax Reitz error_setg_errno(errp, errno, "Could not preallocate data");
105236e87909SMax Reitz return -errno;
105336e87909SMax Reitz }
105436e87909SMax Reitz break;
105536e87909SMax Reitz #endif /* CONFIG_GLUSTERFS_FALLOCATE */
105636e87909SMax Reitz #ifdef CONFIG_GLUSTERFS_ZEROFILL
105736e87909SMax Reitz case PREALLOC_MODE_FULL:
105836e87909SMax Reitz if (glfs_ftruncate(fd, offset)) {
105936e87909SMax Reitz error_setg_errno(errp, errno, "Could not resize file");
106036e87909SMax Reitz return -errno;
106136e87909SMax Reitz }
1062f3a33f79SMax Reitz if (glfs_zerofill(fd, current_length, offset - current_length)) {
106336e87909SMax Reitz error_setg_errno(errp, errno, "Could not zerofill the new area");
106436e87909SMax Reitz return -errno;
106536e87909SMax Reitz }
106636e87909SMax Reitz break;
106736e87909SMax Reitz #endif /* CONFIG_GLUSTERFS_ZEROFILL */
106836e87909SMax Reitz case PREALLOC_MODE_OFF:
106936e87909SMax Reitz if (glfs_ftruncate(fd, offset)) {
107036e87909SMax Reitz error_setg_errno(errp, errno, "Could not resize file");
107136e87909SMax Reitz return -errno;
107236e87909SMax Reitz }
107336e87909SMax Reitz break;
107436e87909SMax Reitz default:
107536e87909SMax Reitz error_setg(errp, "Unsupported preallocation mode: %s",
107636e87909SMax Reitz PreallocMode_str(prealloc));
107736e87909SMax Reitz return -EINVAL;
107836e87909SMax Reitz }
107936e87909SMax Reitz
108036e87909SMax Reitz return 0;
108136e87909SMax Reitz }
108236e87909SMax Reitz
qemu_gluster_co_create(BlockdevCreateOptions * options,Error ** errp)1083ab8bda76SKevin Wolf static int qemu_gluster_co_create(BlockdevCreateOptions *options,
1084ab8bda76SKevin Wolf Error **errp)
1085ab8bda76SKevin Wolf {
1086ab8bda76SKevin Wolf BlockdevCreateOptionsGluster *opts = &options->u.gluster;
1087ab8bda76SKevin Wolf struct glfs *glfs;
1088ab8bda76SKevin Wolf struct glfs_fd *fd = NULL;
1089ab8bda76SKevin Wolf int ret = 0;
1090ab8bda76SKevin Wolf
1091ab8bda76SKevin Wolf assert(options->driver == BLOCKDEV_DRIVER_GLUSTER);
1092ab8bda76SKevin Wolf
1093ab8bda76SKevin Wolf glfs = qemu_gluster_glfs_init(opts->location, errp);
1094ab8bda76SKevin Wolf if (!glfs) {
1095ab8bda76SKevin Wolf ret = -errno;
1096ab8bda76SKevin Wolf goto out;
1097ab8bda76SKevin Wolf }
1098ab8bda76SKevin Wolf
1099ab8bda76SKevin Wolf fd = glfs_creat(glfs, opts->location->path,
1100ab8bda76SKevin Wolf O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR);
1101ab8bda76SKevin Wolf if (!fd) {
1102ab8bda76SKevin Wolf ret = -errno;
1103ab8bda76SKevin Wolf goto out;
1104ab8bda76SKevin Wolf }
1105ab8bda76SKevin Wolf
1106ab8bda76SKevin Wolf ret = qemu_gluster_do_truncate(fd, opts->size, opts->preallocation, errp);
1107ab8bda76SKevin Wolf
1108ab8bda76SKevin Wolf out:
1109ab8bda76SKevin Wolf if (fd) {
1110ab8bda76SKevin Wolf if (glfs_close(fd) != 0 && ret == 0) {
1111ab8bda76SKevin Wolf ret = -errno;
1112ab8bda76SKevin Wolf }
1113ab8bda76SKevin Wolf }
1114ab8bda76SKevin Wolf glfs_clear_preopened(glfs);
1115ab8bda76SKevin Wolf return ret;
1116ab8bda76SKevin Wolf }
1117ab8bda76SKevin Wolf
qemu_gluster_co_create_opts(BlockDriver * drv,const char * filename,QemuOpts * opts,Error ** errp)1118b92902dfSMaxim Levitsky static int coroutine_fn qemu_gluster_co_create_opts(BlockDriver *drv,
1119b92902dfSMaxim Levitsky const char *filename,
1120efc75e2aSStefan Hajnoczi QemuOpts *opts,
1121efc75e2aSStefan Hajnoczi Error **errp)
11228d6d89cbSBharata B Rao {
1123ab8bda76SKevin Wolf BlockdevCreateOptions *options;
1124ab8bda76SKevin Wolf BlockdevCreateOptionsGluster *gopts;
11257edac2ddSPrasanna Kumar Kalever BlockdevOptionsGluster *gconf;
112690c772deSChunyan Liu char *tmp = NULL;
1127df3a429aSNiels de Vos Error *local_err = NULL;
1128ab8bda76SKevin Wolf int ret;
1129ab8bda76SKevin Wolf
1130ab8bda76SKevin Wolf options = g_new0(BlockdevCreateOptions, 1);
1131ab8bda76SKevin Wolf options->driver = BLOCKDEV_DRIVER_GLUSTER;
1132ab8bda76SKevin Wolf gopts = &options->u.gluster;
11338d6d89cbSBharata B Rao
11347edac2ddSPrasanna Kumar Kalever gconf = g_new0(BlockdevOptionsGluster, 1);
1135ab8bda76SKevin Wolf gopts->location = gconf;
1136ab8bda76SKevin Wolf
1137ab8bda76SKevin Wolf gopts->size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1138ab8bda76SKevin Wolf BDRV_SECTOR_SIZE);
1139ab8bda76SKevin Wolf
1140ab8bda76SKevin Wolf tmp = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
1141ab8bda76SKevin Wolf gopts->preallocation = qapi_enum_parse(&PreallocMode_lookup, tmp,
1142ab8bda76SKevin Wolf PREALLOC_MODE_OFF, &local_err);
1143ab8bda76SKevin Wolf g_free(tmp);
1144ab8bda76SKevin Wolf if (local_err) {
1145ab8bda76SKevin Wolf error_propagate(errp, local_err);
1146ab8bda76SKevin Wolf ret = -EINVAL;
1147ab8bda76SKevin Wolf goto fail;
1148ab8bda76SKevin Wolf }
1149ab8bda76SKevin Wolf
11501a417e46SPrasanna Kumar Kalever gconf->debug = qemu_opt_get_number_del(opts, GLUSTER_OPT_DEBUG,
11517eac868aSJeff Cody GLUSTER_DEBUG_DEFAULT);
11521a417e46SPrasanna Kumar Kalever if (gconf->debug < 0) {
11531a417e46SPrasanna Kumar Kalever gconf->debug = 0;
11541a417e46SPrasanna Kumar Kalever } else if (gconf->debug > GLUSTER_DEBUG_MAX) {
11551a417e46SPrasanna Kumar Kalever gconf->debug = GLUSTER_DEBUG_MAX;
11567eac868aSJeff Cody }
11571a417e46SPrasanna Kumar Kalever gconf->has_debug = true;
11587eac868aSJeff Cody
1159e9db8ff3SPrasanna Kumar Kalever gconf->logfile = qemu_opt_get_del(opts, GLUSTER_OPT_LOGFILE);
1160e9db8ff3SPrasanna Kumar Kalever if (!gconf->logfile) {
1161e9db8ff3SPrasanna Kumar Kalever gconf->logfile = g_strdup(GLUSTER_LOGFILE_DEFAULT);
1162e9db8ff3SPrasanna Kumar Kalever }
1163e9db8ff3SPrasanna Kumar Kalever
1164ab8bda76SKevin Wolf ret = qemu_gluster_parse(gconf, filename, NULL, errp);
1165ab8bda76SKevin Wolf if (ret < 0) {
1166ab8bda76SKevin Wolf goto fail;
11678d6d89cbSBharata B Rao }
11688d6d89cbSBharata B Rao
1169ab8bda76SKevin Wolf ret = qemu_gluster_co_create(options, errp);
1170ab8bda76SKevin Wolf if (ret < 0) {
1171ab8bda76SKevin Wolf goto fail;
1172cf7f616bSBharata B Rao }
11738d6d89cbSBharata B Rao
1174ab8bda76SKevin Wolf ret = 0;
1175ab8bda76SKevin Wolf fail:
1176ab8bda76SKevin Wolf qapi_free_BlockdevCreateOptions(options);
11778d6d89cbSBharata B Rao return ret;
11788d6d89cbSBharata B Rao }
11798d6d89cbSBharata B Rao
qemu_gluster_co_rw(BlockDriverState * bs,int64_t sector_num,int nb_sectors,QEMUIOVector * qiov,int write)118015744b0bSBharata B Rao static coroutine_fn int qemu_gluster_co_rw(BlockDriverState *bs,
1181f70c50c8SPrasanna Kumar Kalever int64_t sector_num, int nb_sectors,
1182f70c50c8SPrasanna Kumar Kalever QEMUIOVector *qiov, int write)
11838d6d89cbSBharata B Rao {
11848d6d89cbSBharata B Rao int ret;
1185c833d1e8SPaolo Bonzini GlusterAIOCB acb;
11868d6d89cbSBharata B Rao BDRVGlusterState *s = bs->opaque;
118715744b0bSBharata B Rao size_t size = nb_sectors * BDRV_SECTOR_SIZE;
118815744b0bSBharata B Rao off_t offset = sector_num * BDRV_SECTOR_SIZE;
11898d6d89cbSBharata B Rao
1190c833d1e8SPaolo Bonzini acb.size = size;
1191c833d1e8SPaolo Bonzini acb.ret = 0;
1192c833d1e8SPaolo Bonzini acb.coroutine = qemu_coroutine_self();
1193c833d1e8SPaolo Bonzini acb.aio_context = bdrv_get_aio_context(bs);
11948d6d89cbSBharata B Rao
11958d6d89cbSBharata B Rao if (write) {
11968d6d89cbSBharata B Rao ret = glfs_pwritev_async(s->fd, qiov->iov, qiov->niov, offset, 0,
1197c833d1e8SPaolo Bonzini gluster_finish_aiocb, &acb);
11988d6d89cbSBharata B Rao } else {
11998d6d89cbSBharata B Rao ret = glfs_preadv_async(s->fd, qiov->iov, qiov->niov, offset, 0,
1200c833d1e8SPaolo Bonzini gluster_finish_aiocb, &acb);
12018d6d89cbSBharata B Rao }
12028d6d89cbSBharata B Rao
12038d6d89cbSBharata B Rao if (ret < 0) {
1204c833d1e8SPaolo Bonzini return -errno;
12058d6d89cbSBharata B Rao }
120615744b0bSBharata B Rao
120715744b0bSBharata B Rao qemu_coroutine_yield();
1208c833d1e8SPaolo Bonzini return acb.ret;
12098d6d89cbSBharata B Rao }
12108d6d89cbSBharata B Rao
qemu_gluster_co_truncate(BlockDriverState * bs,int64_t offset,bool exact,PreallocMode prealloc,BdrvRequestFlags flags,Error ** errp)1211061ca8a3SKevin Wolf static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,
1212061ca8a3SKevin Wolf int64_t offset,
1213c80d8b06SMax Reitz bool exact,
1214061ca8a3SKevin Wolf PreallocMode prealloc,
121592b92799SKevin Wolf BdrvRequestFlags flags,
1216061ca8a3SKevin Wolf Error **errp)
121742ec24e2SPaolo Bonzini {
121842ec24e2SPaolo Bonzini BDRVGlusterState *s = bs->opaque;
1219c3132affSMax Reitz return qemu_gluster_do_truncate(s->fd, offset, prealloc, errp);
122042ec24e2SPaolo Bonzini }
122142ec24e2SPaolo Bonzini
qemu_gluster_co_readv(BlockDriverState * bs,int64_t sector_num,int nb_sectors,QEMUIOVector * qiov)122215744b0bSBharata B Rao static coroutine_fn int qemu_gluster_co_readv(BlockDriverState *bs,
1223f70c50c8SPrasanna Kumar Kalever int64_t sector_num,
1224f70c50c8SPrasanna Kumar Kalever int nb_sectors,
1225f70c50c8SPrasanna Kumar Kalever QEMUIOVector *qiov)
12268d6d89cbSBharata B Rao {
122715744b0bSBharata B Rao return qemu_gluster_co_rw(bs, sector_num, nb_sectors, qiov, 0);
12288d6d89cbSBharata B Rao }
12298d6d89cbSBharata B Rao
qemu_gluster_co_writev(BlockDriverState * bs,int64_t sector_num,int nb_sectors,QEMUIOVector * qiov,int flags)123015744b0bSBharata B Rao static coroutine_fn int qemu_gluster_co_writev(BlockDriverState *bs,
1231f70c50c8SPrasanna Kumar Kalever int64_t sector_num,
1232f70c50c8SPrasanna Kumar Kalever int nb_sectors,
1233e18a58b4SEric Blake QEMUIOVector *qiov,
1234e18a58b4SEric Blake int flags)
12358d6d89cbSBharata B Rao {
123615744b0bSBharata B Rao return qemu_gluster_co_rw(bs, sector_num, nb_sectors, qiov, 1);
12378d6d89cbSBharata B Rao }
12388d6d89cbSBharata B Rao
qemu_gluster_close(BlockDriverState * bs)12395d4343e6SJeff Cody static void qemu_gluster_close(BlockDriverState *bs)
12405d4343e6SJeff Cody {
12415d4343e6SJeff Cody BDRVGlusterState *s = bs->opaque;
12425d4343e6SJeff Cody
1243e9db8ff3SPrasanna Kumar Kalever g_free(s->logfile);
12445d4343e6SJeff Cody if (s->fd) {
12455d4343e6SJeff Cody glfs_close(s->fd);
12465d4343e6SJeff Cody s->fd = NULL;
12475d4343e6SJeff Cody }
12486349c154SPrasanna Kumar Kalever glfs_clear_preopened(s->glfs);
12495d4343e6SJeff Cody }
12505d4343e6SJeff Cody
qemu_gluster_co_flush_to_disk(BlockDriverState * bs)125115744b0bSBharata B Rao static coroutine_fn int qemu_gluster_co_flush_to_disk(BlockDriverState *bs)
12528d6d89cbSBharata B Rao {
12538d6d89cbSBharata B Rao int ret;
1254c833d1e8SPaolo Bonzini GlusterAIOCB acb;
12558d6d89cbSBharata B Rao BDRVGlusterState *s = bs->opaque;
12568d6d89cbSBharata B Rao
1257c833d1e8SPaolo Bonzini acb.size = 0;
1258c833d1e8SPaolo Bonzini acb.ret = 0;
1259c833d1e8SPaolo Bonzini acb.coroutine = qemu_coroutine_self();
1260c833d1e8SPaolo Bonzini acb.aio_context = bdrv_get_aio_context(bs);
12618d6d89cbSBharata B Rao
1262c833d1e8SPaolo Bonzini ret = glfs_fsync_async(s->fd, gluster_finish_aiocb, &acb);
12638d6d89cbSBharata B Rao if (ret < 0) {
1264d85fa9ebSJeff Cody ret = -errno;
1265d85fa9ebSJeff Cody goto error;
12668d6d89cbSBharata B Rao }
126715744b0bSBharata B Rao
126815744b0bSBharata B Rao qemu_coroutine_yield();
1269d85fa9ebSJeff Cody if (acb.ret < 0) {
1270d85fa9ebSJeff Cody ret = acb.ret;
1271d85fa9ebSJeff Cody goto error;
1272d85fa9ebSJeff Cody }
1273d85fa9ebSJeff Cody
1274c833d1e8SPaolo Bonzini return acb.ret;
1275d85fa9ebSJeff Cody
1276d85fa9ebSJeff Cody error:
1277d85fa9ebSJeff Cody /* Some versions of Gluster (3.5.6 -> 3.5.8?) will not retain its cache
1278d85fa9ebSJeff Cody * after a fsync failure, so we have no way of allowing the guest to safely
1279d85fa9ebSJeff Cody * continue. Gluster versions prior to 3.5.6 don't retain the cache
1280d85fa9ebSJeff Cody * either, but will invalidate the fd on error, so this is again our only
1281d85fa9ebSJeff Cody * option.
1282d85fa9ebSJeff Cody *
1283d85fa9ebSJeff Cody * The 'resync-failed-syncs-after-fsync' xlator option for the
1284d85fa9ebSJeff Cody * write-behind cache will cause later gluster versions to retain its
1285d85fa9ebSJeff Cody * cache after error, so long as the fd remains open. However, we
1286d85fa9ebSJeff Cody * currently have no way of knowing if this option is supported.
1287d85fa9ebSJeff Cody *
1288d85fa9ebSJeff Cody * TODO: Once gluster provides a way for us to determine if the option
1289d85fa9ebSJeff Cody * is supported, bypass the closure and setting drv to NULL. */
1290d85fa9ebSJeff Cody qemu_gluster_close(bs);
1291d85fa9ebSJeff Cody bs->drv = NULL;
1292d85fa9ebSJeff Cody return ret;
12938d6d89cbSBharata B Rao }
12948d6d89cbSBharata B Rao
12950c14fb47SBharata B Rao #ifdef CONFIG_GLUSTERFS_DISCARD
qemu_gluster_co_pdiscard(BlockDriverState * bs,int64_t offset,int64_t bytes)12961014170bSEric Blake static coroutine_fn int qemu_gluster_co_pdiscard(BlockDriverState *bs,
12970c802287SVladimir Sementsov-Ogievskiy int64_t offset, int64_t bytes)
12980c14fb47SBharata B Rao {
12990c14fb47SBharata B Rao int ret;
1300c833d1e8SPaolo Bonzini GlusterAIOCB acb;
13010c14fb47SBharata B Rao BDRVGlusterState *s = bs->opaque;
13020c14fb47SBharata B Rao
13030c802287SVladimir Sementsov-Ogievskiy assert(bytes <= SIZE_MAX); /* rely on max_pdiscard */
13040c802287SVladimir Sementsov-Ogievskiy
1305c833d1e8SPaolo Bonzini acb.size = 0;
1306c833d1e8SPaolo Bonzini acb.ret = 0;
1307c833d1e8SPaolo Bonzini acb.coroutine = qemu_coroutine_self();
1308c833d1e8SPaolo Bonzini acb.aio_context = bdrv_get_aio_context(bs);
13090c14fb47SBharata B Rao
13100c802287SVladimir Sementsov-Ogievskiy ret = glfs_discard_async(s->fd, offset, bytes, gluster_finish_aiocb, &acb);
13110c14fb47SBharata B Rao if (ret < 0) {
1312c833d1e8SPaolo Bonzini return -errno;
13130c14fb47SBharata B Rao }
131415744b0bSBharata B Rao
131515744b0bSBharata B Rao qemu_coroutine_yield();
1316c833d1e8SPaolo Bonzini return acb.ret;
13170c14fb47SBharata B Rao }
13180c14fb47SBharata B Rao #endif
13190c14fb47SBharata B Rao
qemu_gluster_co_getlength(BlockDriverState * bs)1320c86422c5SEmanuele Giuseppe Esposito static int64_t coroutine_fn qemu_gluster_co_getlength(BlockDriverState *bs)
13218d6d89cbSBharata B Rao {
13228d6d89cbSBharata B Rao BDRVGlusterState *s = bs->opaque;
13238d6d89cbSBharata B Rao int64_t ret;
13248d6d89cbSBharata B Rao
13258d6d89cbSBharata B Rao ret = glfs_lseek(s->fd, 0, SEEK_END);
13268d6d89cbSBharata B Rao if (ret < 0) {
13278d6d89cbSBharata B Rao return -errno;
13288d6d89cbSBharata B Rao } else {
13298d6d89cbSBharata B Rao return ret;
13308d6d89cbSBharata B Rao }
13318d6d89cbSBharata B Rao }
13328d6d89cbSBharata B Rao
133382618d7bSEmanuele Giuseppe Esposito static int64_t coroutine_fn
qemu_gluster_co_get_allocated_file_size(BlockDriverState * bs)133482618d7bSEmanuele Giuseppe Esposito qemu_gluster_co_get_allocated_file_size(BlockDriverState *bs)
13358d6d89cbSBharata B Rao {
13368d6d89cbSBharata B Rao BDRVGlusterState *s = bs->opaque;
13378d6d89cbSBharata B Rao struct stat st;
13388d6d89cbSBharata B Rao int ret;
13398d6d89cbSBharata B Rao
13408d6d89cbSBharata B Rao ret = glfs_fstat(s->fd, &st);
13418d6d89cbSBharata B Rao if (ret < 0) {
13428d6d89cbSBharata B Rao return -errno;
13438d6d89cbSBharata B Rao } else {
13448d6d89cbSBharata B Rao return st.st_blocks * 512;
13458d6d89cbSBharata B Rao }
13468d6d89cbSBharata B Rao }
13478d6d89cbSBharata B Rao
1348947eb203SNiels de Vos /*
1349947eb203SNiels de Vos * Find allocation range in @bs around offset @start.
1350947eb203SNiels de Vos * May change underlying file descriptor's file offset.
1351947eb203SNiels de Vos * If @start is not in a hole, store @start in @data, and the
1352947eb203SNiels de Vos * beginning of the next hole in @hole, and return 0.
1353947eb203SNiels de Vos * If @start is in a non-trailing hole, store @start in @hole and the
1354947eb203SNiels de Vos * beginning of the next non-hole in @data, and return 0.
1355947eb203SNiels de Vos * If @start is in a trailing hole or beyond EOF, return -ENXIO.
1356947eb203SNiels de Vos * If we can't find out, return a negative errno other than -ENXIO.
1357947eb203SNiels de Vos *
135850d6a8a3SStefan Weil * (Shamefully copied from file-posix.c, only minuscule adaptions.)
1359947eb203SNiels de Vos */
find_allocation(BlockDriverState * bs,off_t start,off_t * data,off_t * hole)1360947eb203SNiels de Vos static int find_allocation(BlockDriverState *bs, off_t start,
1361947eb203SNiels de Vos off_t *data, off_t *hole)
1362947eb203SNiels de Vos {
1363947eb203SNiels de Vos BDRVGlusterState *s = bs->opaque;
1364947eb203SNiels de Vos
1365947eb203SNiels de Vos if (!s->supports_seek_data) {
1366d9b78974SJeff Cody goto exit;
1367947eb203SNiels de Vos }
1368947eb203SNiels de Vos
1369d9b78974SJeff Cody #if defined SEEK_HOLE && defined SEEK_DATA
1370d9b78974SJeff Cody off_t offs;
1371d9b78974SJeff Cody
1372947eb203SNiels de Vos /*
1373947eb203SNiels de Vos * SEEK_DATA cases:
1374947eb203SNiels de Vos * D1. offs == start: start is in data
1375947eb203SNiels de Vos * D2. offs > start: start is in a hole, next data at offs
1376947eb203SNiels de Vos * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
1377947eb203SNiels de Vos * or start is beyond EOF
1378947eb203SNiels de Vos * If the latter happens, the file has been truncated behind
1379947eb203SNiels de Vos * our back since we opened it. All bets are off then.
1380947eb203SNiels de Vos * Treating like a trailing hole is simplest.
1381947eb203SNiels de Vos * D4. offs < 0, errno != ENXIO: we learned nothing
1382947eb203SNiels de Vos */
1383947eb203SNiels de Vos offs = glfs_lseek(s->fd, start, SEEK_DATA);
1384947eb203SNiels de Vos if (offs < 0) {
1385947eb203SNiels de Vos return -errno; /* D3 or D4 */
1386947eb203SNiels de Vos }
1387223a23c1SJeff Cody
1388223a23c1SJeff Cody if (offs < start) {
1389223a23c1SJeff Cody /* This is not a valid return by lseek(). We are safe to just return
1390223a23c1SJeff Cody * -EIO in this case, and we'll treat it like D4. Unfortunately some
1391223a23c1SJeff Cody * versions of gluster server will return offs < start, so an assert
1392223a23c1SJeff Cody * here will unnecessarily abort QEMU. */
1393223a23c1SJeff Cody return -EIO;
1394223a23c1SJeff Cody }
1395947eb203SNiels de Vos
1396947eb203SNiels de Vos if (offs > start) {
1397947eb203SNiels de Vos /* D2: in hole, next data at offs */
1398947eb203SNiels de Vos *hole = start;
1399947eb203SNiels de Vos *data = offs;
1400947eb203SNiels de Vos return 0;
1401947eb203SNiels de Vos }
1402947eb203SNiels de Vos
1403947eb203SNiels de Vos /* D1: in data, end not yet known */
1404947eb203SNiels de Vos
1405947eb203SNiels de Vos /*
1406947eb203SNiels de Vos * SEEK_HOLE cases:
1407947eb203SNiels de Vos * H1. offs == start: start is in a hole
1408947eb203SNiels de Vos * If this happens here, a hole has been dug behind our back
1409947eb203SNiels de Vos * since the previous lseek().
1410947eb203SNiels de Vos * H2. offs > start: either start is in data, next hole at offs,
1411947eb203SNiels de Vos * or start is in trailing hole, EOF at offs
1412947eb203SNiels de Vos * Linux treats trailing holes like any other hole: offs ==
1413947eb203SNiels de Vos * start. Solaris seeks to EOF instead: offs > start (blech).
1414947eb203SNiels de Vos * If that happens here, a hole has been dug behind our back
1415947eb203SNiels de Vos * since the previous lseek().
1416947eb203SNiels de Vos * H3. offs < 0, errno = ENXIO: start is beyond EOF
1417947eb203SNiels de Vos * If this happens, the file has been truncated behind our
1418947eb203SNiels de Vos * back since we opened it. Treat it like a trailing hole.
1419947eb203SNiels de Vos * H4. offs < 0, errno != ENXIO: we learned nothing
1420947eb203SNiels de Vos * Pretend we know nothing at all, i.e. "forget" about D1.
1421947eb203SNiels de Vos */
1422947eb203SNiels de Vos offs = glfs_lseek(s->fd, start, SEEK_HOLE);
1423947eb203SNiels de Vos if (offs < 0) {
1424947eb203SNiels de Vos return -errno; /* D1 and (H3 or H4) */
1425947eb203SNiels de Vos }
1426223a23c1SJeff Cody
1427223a23c1SJeff Cody if (offs < start) {
1428223a23c1SJeff Cody /* This is not a valid return by lseek(). We are safe to just return
1429223a23c1SJeff Cody * -EIO in this case, and we'll treat it like H4. Unfortunately some
1430223a23c1SJeff Cody * versions of gluster server will return offs < start, so an assert
1431223a23c1SJeff Cody * here will unnecessarily abort QEMU. */
1432223a23c1SJeff Cody return -EIO;
1433223a23c1SJeff Cody }
1434947eb203SNiels de Vos
1435947eb203SNiels de Vos if (offs > start) {
1436947eb203SNiels de Vos /*
1437947eb203SNiels de Vos * D1 and H2: either in data, next hole at offs, or it was in
1438947eb203SNiels de Vos * data but is now in a trailing hole. In the latter case,
1439947eb203SNiels de Vos * all bets are off. Treating it as if it there was data all
1440947eb203SNiels de Vos * the way to EOF is safe, so simply do that.
1441947eb203SNiels de Vos */
1442947eb203SNiels de Vos *data = start;
1443947eb203SNiels de Vos *hole = offs;
1444947eb203SNiels de Vos return 0;
1445947eb203SNiels de Vos }
1446947eb203SNiels de Vos
1447947eb203SNiels de Vos /* D1 and H1 */
1448947eb203SNiels de Vos return -EBUSY;
1449d9b78974SJeff Cody #endif
1450d9b78974SJeff Cody
1451d9b78974SJeff Cody exit:
1452d9b78974SJeff Cody return -ENOTSUP;
1453947eb203SNiels de Vos }
1454947eb203SNiels de Vos
1455947eb203SNiels de Vos /*
145608c9e773SEric Blake * Returns the allocation status of the specified offset.
1457947eb203SNiels de Vos *
145808c9e773SEric Blake * The block layer guarantees 'offset' and 'bytes' are within bounds.
1459947eb203SNiels de Vos *
146008c9e773SEric Blake * 'pnum' is set to the number of bytes (including and immediately following
146108c9e773SEric Blake * the specified offset) that are known to be in the same
1462947eb203SNiels de Vos * allocated/unallocated state.
1463947eb203SNiels de Vos *
146472b4cabeSHanna Reitz * 'bytes' is a soft cap for 'pnum'. If the information is free, 'pnum' may
146572b4cabeSHanna Reitz * well exceed it.
1466947eb203SNiels de Vos *
146708c9e773SEric Blake * (Based on raw_co_block_status() from file-posix.c.)
1468947eb203SNiels de Vos */
qemu_gluster_co_block_status(BlockDriverState * bs,bool want_zero,int64_t offset,int64_t bytes,int64_t * pnum,int64_t * map,BlockDriverState ** file)146908c9e773SEric Blake static int coroutine_fn qemu_gluster_co_block_status(BlockDriverState *bs,
147008c9e773SEric Blake bool want_zero,
147108c9e773SEric Blake int64_t offset,
147208c9e773SEric Blake int64_t bytes,
147308c9e773SEric Blake int64_t *pnum,
147408c9e773SEric Blake int64_t *map,
1475947eb203SNiels de Vos BlockDriverState **file)
1476947eb203SNiels de Vos {
1477947eb203SNiels de Vos BDRVGlusterState *s = bs->opaque;
147808c9e773SEric Blake off_t data = 0, hole = 0;
1479947eb203SNiels de Vos int ret = -EINVAL;
1480947eb203SNiels de Vos
1481e24154d8SMax Reitz assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
1482e24154d8SMax Reitz
1483947eb203SNiels de Vos if (!s->fd) {
1484947eb203SNiels de Vos return ret;
1485947eb203SNiels de Vos }
1486947eb203SNiels de Vos
148708c9e773SEric Blake if (!want_zero) {
148808c9e773SEric Blake *pnum = bytes;
148908c9e773SEric Blake *map = offset;
149008c9e773SEric Blake *file = bs;
149108c9e773SEric Blake return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
1492947eb203SNiels de Vos }
1493947eb203SNiels de Vos
149408c9e773SEric Blake ret = find_allocation(bs, offset, &data, &hole);
1495947eb203SNiels de Vos if (ret == -ENXIO) {
1496947eb203SNiels de Vos /* Trailing hole */
149708c9e773SEric Blake *pnum = bytes;
1498947eb203SNiels de Vos ret = BDRV_BLOCK_ZERO;
1499947eb203SNiels de Vos } else if (ret < 0) {
1500947eb203SNiels de Vos /* No info available, so pretend there are no holes */
150108c9e773SEric Blake *pnum = bytes;
1502947eb203SNiels de Vos ret = BDRV_BLOCK_DATA;
150308c9e773SEric Blake } else if (data == offset) {
150408c9e773SEric Blake /* On a data extent, compute bytes to the end of the extent,
1505947eb203SNiels de Vos * possibly including a partial sector at EOF. */
150672b4cabeSHanna Reitz *pnum = hole - offset;
1507e24154d8SMax Reitz
1508e24154d8SMax Reitz /*
1509e24154d8SMax Reitz * We are not allowed to return partial sectors, though, so
1510e24154d8SMax Reitz * round up if necessary.
1511e24154d8SMax Reitz */
1512e24154d8SMax Reitz if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
1513c86422c5SEmanuele Giuseppe Esposito int64_t file_length = qemu_gluster_co_getlength(bs);
1514e24154d8SMax Reitz if (file_length > 0) {
1515e24154d8SMax Reitz /* Ignore errors, this is just a safeguard */
1516e24154d8SMax Reitz assert(hole == file_length);
1517e24154d8SMax Reitz }
1518e24154d8SMax Reitz *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
1519e24154d8SMax Reitz }
1520e24154d8SMax Reitz
1521947eb203SNiels de Vos ret = BDRV_BLOCK_DATA;
1522947eb203SNiels de Vos } else {
152308c9e773SEric Blake /* On a hole, compute bytes to the beginning of the next extent. */
152408c9e773SEric Blake assert(hole == offset);
152572b4cabeSHanna Reitz *pnum = data - offset;
1526947eb203SNiels de Vos ret = BDRV_BLOCK_ZERO;
1527947eb203SNiels de Vos }
1528947eb203SNiels de Vos
152908c9e773SEric Blake *map = offset;
1530947eb203SNiels de Vos *file = bs;
1531947eb203SNiels de Vos
153208c9e773SEric Blake return ret | BDRV_BLOCK_OFFSET_VALID;
1533947eb203SNiels de Vos }
1534947eb203SNiels de Vos
1535947eb203SNiels de Vos
15362654267cSMax Reitz static const char *const gluster_strong_open_opts[] = {
15372654267cSMax Reitz GLUSTER_OPT_VOLUME,
15382654267cSMax Reitz GLUSTER_OPT_PATH,
15392654267cSMax Reitz GLUSTER_OPT_TYPE,
15402654267cSMax Reitz GLUSTER_OPT_SERVER_PATTERN,
15412654267cSMax Reitz GLUSTER_OPT_HOST,
15422654267cSMax Reitz GLUSTER_OPT_PORT,
15432654267cSMax Reitz GLUSTER_OPT_TO,
15442654267cSMax Reitz GLUSTER_OPT_IPV4,
15452654267cSMax Reitz GLUSTER_OPT_IPV6,
15462654267cSMax Reitz GLUSTER_OPT_SOCKET,
15472654267cSMax Reitz
15482654267cSMax Reitz NULL
15492654267cSMax Reitz };
15502654267cSMax Reitz
15518d6d89cbSBharata B Rao static BlockDriver bdrv_gluster = {
15528d6d89cbSBharata B Rao .format_name = "gluster",
15538d6d89cbSBharata B Rao .protocol_name = "gluster",
15548d6d89cbSBharata B Rao .instance_size = sizeof(BDRVGlusterState),
15558d6d89cbSBharata B Rao .bdrv_file_open = qemu_gluster_open,
1556adccfbcdSJeff Cody .bdrv_reopen_prepare = qemu_gluster_reopen_prepare,
1557adccfbcdSJeff Cody .bdrv_reopen_commit = qemu_gluster_reopen_commit,
1558adccfbcdSJeff Cody .bdrv_reopen_abort = qemu_gluster_reopen_abort,
15598d6d89cbSBharata B Rao .bdrv_close = qemu_gluster_close,
1560ab8bda76SKevin Wolf .bdrv_co_create = qemu_gluster_co_create,
1561efc75e2aSStefan Hajnoczi .bdrv_co_create_opts = qemu_gluster_co_create_opts,
1562c86422c5SEmanuele Giuseppe Esposito .bdrv_co_getlength = qemu_gluster_co_getlength,
156382618d7bSEmanuele Giuseppe Esposito .bdrv_co_get_allocated_file_size = qemu_gluster_co_get_allocated_file_size,
1564061ca8a3SKevin Wolf .bdrv_co_truncate = qemu_gluster_co_truncate,
156515744b0bSBharata B Rao .bdrv_co_readv = qemu_gluster_co_readv,
156615744b0bSBharata B Rao .bdrv_co_writev = qemu_gluster_co_writev,
156715744b0bSBharata B Rao .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,
15680c14fb47SBharata B Rao #ifdef CONFIG_GLUSTERFS_DISCARD
15691014170bSEric Blake .bdrv_co_pdiscard = qemu_gluster_co_pdiscard,
15700c14fb47SBharata B Rao #endif
15717c815372SBharata B Rao #ifdef CONFIG_GLUSTERFS_ZEROFILL
1572e88a36ebSEric Blake .bdrv_co_pwrite_zeroes = qemu_gluster_co_pwrite_zeroes,
15737c815372SBharata B Rao #endif
157408c9e773SEric Blake .bdrv_co_block_status = qemu_gluster_co_block_status,
1575de23e72bSStefano Garzarella .bdrv_refresh_limits = qemu_gluster_refresh_limits,
157690c772deSChunyan Liu .create_opts = &qemu_gluster_create_opts,
15772654267cSMax Reitz .strong_runtime_opts = gluster_strong_open_opts,
15788d6d89cbSBharata B Rao };
15798d6d89cbSBharata B Rao
15808d6d89cbSBharata B Rao static BlockDriver bdrv_gluster_tcp = {
15818d6d89cbSBharata B Rao .format_name = "gluster",
15828d6d89cbSBharata B Rao .protocol_name = "gluster+tcp",
15838d6d89cbSBharata B Rao .instance_size = sizeof(BDRVGlusterState),
15848d6d89cbSBharata B Rao .bdrv_file_open = qemu_gluster_open,
1585adccfbcdSJeff Cody .bdrv_reopen_prepare = qemu_gluster_reopen_prepare,
1586adccfbcdSJeff Cody .bdrv_reopen_commit = qemu_gluster_reopen_commit,
1587adccfbcdSJeff Cody .bdrv_reopen_abort = qemu_gluster_reopen_abort,
15888d6d89cbSBharata B Rao .bdrv_close = qemu_gluster_close,
1589ab8bda76SKevin Wolf .bdrv_co_create = qemu_gluster_co_create,
1590efc75e2aSStefan Hajnoczi .bdrv_co_create_opts = qemu_gluster_co_create_opts,
1591c86422c5SEmanuele Giuseppe Esposito .bdrv_co_getlength = qemu_gluster_co_getlength,
159282618d7bSEmanuele Giuseppe Esposito .bdrv_co_get_allocated_file_size = qemu_gluster_co_get_allocated_file_size,
1593061ca8a3SKevin Wolf .bdrv_co_truncate = qemu_gluster_co_truncate,
159415744b0bSBharata B Rao .bdrv_co_readv = qemu_gluster_co_readv,
159515744b0bSBharata B Rao .bdrv_co_writev = qemu_gluster_co_writev,
159615744b0bSBharata B Rao .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,
15970c14fb47SBharata B Rao #ifdef CONFIG_GLUSTERFS_DISCARD
15981014170bSEric Blake .bdrv_co_pdiscard = qemu_gluster_co_pdiscard,
15990c14fb47SBharata B Rao #endif
16007c815372SBharata B Rao #ifdef CONFIG_GLUSTERFS_ZEROFILL
1601e88a36ebSEric Blake .bdrv_co_pwrite_zeroes = qemu_gluster_co_pwrite_zeroes,
16027c815372SBharata B Rao #endif
160308c9e773SEric Blake .bdrv_co_block_status = qemu_gluster_co_block_status,
1604de23e72bSStefano Garzarella .bdrv_refresh_limits = qemu_gluster_refresh_limits,
160590c772deSChunyan Liu .create_opts = &qemu_gluster_create_opts,
16062654267cSMax Reitz .strong_runtime_opts = gluster_strong_open_opts,
16078d6d89cbSBharata B Rao };
16088d6d89cbSBharata B Rao
16098d6d89cbSBharata B Rao static BlockDriver bdrv_gluster_unix = {
16108d6d89cbSBharata B Rao .format_name = "gluster",
16118d6d89cbSBharata B Rao .protocol_name = "gluster+unix",
16128d6d89cbSBharata B Rao .instance_size = sizeof(BDRVGlusterState),
16138d6d89cbSBharata B Rao .bdrv_file_open = qemu_gluster_open,
1614adccfbcdSJeff Cody .bdrv_reopen_prepare = qemu_gluster_reopen_prepare,
1615adccfbcdSJeff Cody .bdrv_reopen_commit = qemu_gluster_reopen_commit,
1616adccfbcdSJeff Cody .bdrv_reopen_abort = qemu_gluster_reopen_abort,
16178d6d89cbSBharata B Rao .bdrv_close = qemu_gluster_close,
1618ab8bda76SKevin Wolf .bdrv_co_create = qemu_gluster_co_create,
1619efc75e2aSStefan Hajnoczi .bdrv_co_create_opts = qemu_gluster_co_create_opts,
1620c86422c5SEmanuele Giuseppe Esposito .bdrv_co_getlength = qemu_gluster_co_getlength,
162182618d7bSEmanuele Giuseppe Esposito .bdrv_co_get_allocated_file_size = qemu_gluster_co_get_allocated_file_size,
1622061ca8a3SKevin Wolf .bdrv_co_truncate = qemu_gluster_co_truncate,
162315744b0bSBharata B Rao .bdrv_co_readv = qemu_gluster_co_readv,
162415744b0bSBharata B Rao .bdrv_co_writev = qemu_gluster_co_writev,
162515744b0bSBharata B Rao .bdrv_co_flush_to_disk = qemu_gluster_co_flush_to_disk,
16260c14fb47SBharata B Rao #ifdef CONFIG_GLUSTERFS_DISCARD
16271014170bSEric Blake .bdrv_co_pdiscard = qemu_gluster_co_pdiscard,
16280c14fb47SBharata B Rao #endif
16297c815372SBharata B Rao #ifdef CONFIG_GLUSTERFS_ZEROFILL
1630e88a36ebSEric Blake .bdrv_co_pwrite_zeroes = qemu_gluster_co_pwrite_zeroes,
16317c815372SBharata B Rao #endif
163208c9e773SEric Blake .bdrv_co_block_status = qemu_gluster_co_block_status,
1633de23e72bSStefano Garzarella .bdrv_refresh_limits = qemu_gluster_refresh_limits,
163490c772deSChunyan Liu .create_opts = &qemu_gluster_create_opts,
16352654267cSMax Reitz .strong_runtime_opts = gluster_strong_open_opts,
16368d6d89cbSBharata B Rao };
16378d6d89cbSBharata B Rao
bdrv_gluster_init(void)16388d6d89cbSBharata B Rao static void bdrv_gluster_init(void)
16398d6d89cbSBharata B Rao {
16408d6d89cbSBharata B Rao bdrv_register(&bdrv_gluster_unix);
16418d6d89cbSBharata B Rao bdrv_register(&bdrv_gluster_tcp);
16428d6d89cbSBharata B Rao bdrv_register(&bdrv_gluster);
16438d6d89cbSBharata B Rao }
16448d6d89cbSBharata B Rao
16458d6d89cbSBharata B Rao block_init(bdrv_gluster_init);
1646