[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [PATCH v6 1/1] block/gluster: add support for multiple glus
|
From: |
Prasanna Kumar Kalever |
|
Subject: |
[Qemu-devel] [PATCH v6 1/1] block/gluster: add support for multiple gluster backup volfile servers |
|
Date: |
Sat, 10 Oct 2015 19:16:23 +0530 |
This patch adds a way to specify multiple volfile servers to the gluster
block backend of QEMU with tcp|rdma transport types and their port numbers.
Problem:
Currenly VM Image on gluster volume is specified like this:
file=gluster[+tcp]://host[:port]/testvol/a.img
Assuming we have three hosts in trustred pool with replica 3 volume
in action and unfortunately host (mentioned in the command above) went down
for some reason, since the volume is replica 3 we now have other 2 hosts
active from which we can boot the VM.
But currently there is no mechanism to pass the other 2 gluster host
addresses to qemu.
Solution:
New way of specifying VM Image on gluster volume with volfile servers:
(We still support old syntax to maintain backward compatibility)
Basic command line syntax looks like:
Pattern I:
-drive driver=gluster,
volume=testvol,path=/path/a.raw,
servers.0.host=1.2.3.4,
[servers.0.port=24007,]
[servers.0.transport=tcp,]
servers.1.host=5.6.7.8,
[servers.1.port=24008,]
[servers.1.transport=rdma,] ...
Pattern II:
'json:{"driver":"qcow2","file":{"driver":"gluster",
"volume":"testvol","path":"/path/a.qcow2",
"servers":[{tuple0},{tuple1}, ...{tupleN}]}}'
driver => 'gluster' (protocol name)
volume => name of gluster volume where our VM image resides
path => absolute path of image in gluster volume
{tuple} => {"host":"1.2.3.4"[,"port":"24007","transport":"tcp"]}
host => host address (hostname/ipv4/ipv6 addresses)
port => port number on which glusterd is listening. (default 24007)
tranport => transport type used to connect to gluster management daemon,
it can be tcp|rdma (default 'tcp')
Examples:
1.
-drive driver=qcow2,file.driver=gluster,
file.volume=testvol,file.path=/path/a.qcow2,
file.servers.0.host=1.2.3.4,
file.servers.0.port=24007,
file.servers.0.transport=tcp,
file.servers.1.host=5.6.7.8,
file.servers.1.port=24008,
file.servers.1.transport=rdma
2.
'json:{"driver":"qcow2","file":{"driver":"gluster","volume":"testvol",
"path":"/path/a.qcow2","servers":
[{"host":"1.2.3.4","port":"24007","transport":"tcp"},
{"host":"4.5.6.7","port":"24008","transport":"rdma"}] } }'
This patch gives a mechanism to provide all the server addresses, which are in
replica set, so in case host1 is down VM can still boot from any of the
active hosts.
This is equivalent to the backup-volfile-servers option supported by
mount.glusterfs (FUSE way of mounting gluster volume)
This patch depends on a recent fix in libgfapi raised as part of this work:
http://review.gluster.org/#/c/12114/
Credits: Sincere thanks to Kevin Wolf <address@hidden> and
"Deepak C Shetty" <address@hidden> for inputs and all their support
Signed-off-by: Prasanna Kumar Kalever <address@hidden>
---
v1:
multiple host addresses but common port number and transport type
pattern: URI syntax with query (?) delimitor
syntax:
file=gluster[+transport-type]://host1:24007/testvol/a.img\
?servers=host2&servers=host3
v2:
multiple host addresses each have their own port number, but all use
common transport type
pattern: URI syntax with query (?) delimiter
syntax:
file=gluster[+transport-type]://[host[:port]]/testvol/a.img\
[?servers=host1[:port]\
&servers=host2[:port]]
v3:
multiple host addresses each have their own port number and transport type
pattern: changed to json
syntax:
'json:{"driver":"qcow2","file":{"driver":"gluster","volume":"testvol",
"path":"/path/a.qcow2","servers":
[{"host":"1.2.3.4","port":"24007","transport":"tcp"},
{"host":"4.5.6.7","port":"24008","transport":"rdma"}] } }'
v4, v5:
address comments from "Eric Blake" <address@hidden>
renamed:
'backup-volfile-servers' -> 'volfile-servers'
v6:
address comments from Peter Krempa <address@hidden>
renamed:
'volname' -> 'volume'
'image-path' -> 'path'
'server' -> 'host'
'volfile-servers' -> 'servers'
---
block/gluster.c | 563 +++++++++++++++++++++++++++++++++++++++++----------
qapi/block-core.json | 60 +++++-
2 files changed, 514 insertions(+), 109 deletions(-)
diff --git a/block/gluster.c b/block/gluster.c
index 1eb3a8c..c9061af 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -11,6 +11,17 @@
#include "block/block_int.h"
#include "qemu/uri.h"
+#define GLUSTER_OPT_FILENAME "filename"
+#define GLUSTER_OPT_VOLUME "volume"
+#define GLUSTER_OPT_PATH "path"
+#define GLUSTER_OPT_HOST "host"
+#define GLUSTER_OPT_PORT "port"
+#define GLUSTER_OPT_TRANSPORT "transport"
+#define GLUSTER_OPT_SERVER_PATTERN "servers."
+
+#define GLUSTER_DEFAULT_PORT 24007
+#define GLUSTER_DEFAULT_TRANSPORT "tcp"
+
typedef struct GlusterAIOCB {
int64_t size;
int ret;
@@ -24,22 +35,108 @@ typedef struct BDRVGlusterState {
struct glfs_fd *fd;
} BDRVGlusterState;
-typedef struct GlusterConf {
- char *server;
- int port;
- char *volname;
- char *image;
+typedef struct BDRVGlusterReopenState {
+ struct glfs *glfs;
+ struct glfs_fd *fd;
+} BDRVGlusterReopenState;
+
+typedef struct GlusterServerConf {
+ char *host;
+ int port;
char *transport;
+} GlusterServerConf;
+
+typedef struct GlusterConf {
+ char *volume;
+ char *path;
+ GlusterServerConf *gsconf;
} GlusterConf;
+static QemuOptsList qemu_gluster_create_opts = {
+ .name = "qemu-gluster-create-opts",
+ .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head),
+ .desc = {
+ {
+ .name = BLOCK_OPT_SIZE,
+ .type = QEMU_OPT_SIZE,
+ .help = "Virtual disk size"
+ },
+ {
+ .name = BLOCK_OPT_PREALLOC,
+ .type = QEMU_OPT_STRING,
+ .help = "Preallocation mode (allowed values: off, full)"
+ },
+ { /* end of list */ }
+ }
+};
+
+static QemuOptsList runtime_opts = {
+ .name = "gluster",
+ .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
+ .desc = {
+ {
+ .name = GLUSTER_OPT_FILENAME,
+ .type = QEMU_OPT_STRING,
+ .help = "URL to the gluster image",
+ },
+ { /* end of list */ }
+ },
+};
+
+static QemuOptsList runtime_json_opts = {
+ .name = "gluster_json",
+ .head = QTAILQ_HEAD_INITIALIZER(runtime_json_opts.head),
+ .desc = {
+ {
+ .name = GLUSTER_OPT_VOLUME,
+ .type = QEMU_OPT_STRING,
+ .help = "name of gluster volume where our VM image resides",
+ },
+ {
+ .name = GLUSTER_OPT_PATH,
+ .type = QEMU_OPT_STRING,
+ .help = "absolute path to image file in gluster volume",
+ },
+ { /* end of list */ }
+ },
+};
+
+static QemuOptsList runtime_tuple_opts = {
+ .name = "gluster_tuple",
+ .head = QTAILQ_HEAD_INITIALIZER(runtime_tuple_opts.head),
+ .desc = {
+ {
+ .name = GLUSTER_OPT_HOST,
+ .type = QEMU_OPT_STRING,
+ .help = "host address (hostname/ipv4/ipv6 addresses)",
+ },
+ {
+ .name = GLUSTER_OPT_PORT,
+ .type = QEMU_OPT_NUMBER,
+ .help = "port number on which glusterd is listening(default
24007)",
+ },
+ {
+ .name = GLUSTER_OPT_TRANSPORT,
+ .type = QEMU_OPT_STRING,
+ .help = "transport type used to connect to glusterd(default tcp)",
+ },
+ { /* end of list */ }
+ },
+};
+
static void qemu_gluster_gconf_free(GlusterConf *gconf)
{
if (gconf) {
- g_free(gconf->server);
- g_free(gconf->volname);
- g_free(gconf->image);
- g_free(gconf->transport);
+ g_free(gconf->volume);
+ g_free(gconf->path);
+ if (gconf->gsconf) {
+ g_free(gconf->gsconf[0].host);
+ g_free(gconf->gsconf[0].transport);
+ g_free(gconf->gsconf);
+ gconf->gsconf = NULL;
+ }
g_free(gconf);
+ gconf = NULL;
}
}
@@ -57,19 +154,19 @@ static int parse_volume_options(GlusterConf *gconf, char
*path)
if (*p == '\0') {
return -EINVAL;
}
- gconf->volname = g_strndup(q, p - q);
+ gconf->volume = g_strndup(q, p - q);
- /* image */
+ /* path */
p += strspn(p, "/");
if (*p == '\0') {
return -EINVAL;
}
- gconf->image = g_strdup(p);
+ gconf->path = g_strdup(p);
return 0;
}
/*
- * file=gluster[+transport]://[server[:port]]/volname/image[?socket=...]
+ * file=gluster[+transport]://[host[:port]]/volume/path[?socket=...]
*
* 'gluster' is the protocol.
*
@@ -78,10 +175,10 @@ static int parse_volume_options(GlusterConf *gconf, char
*path)
* tcp, unix and rdma. If a transport type isn't specified, then tcp
* type is assumed.
*
- * 'server' specifies the server where the volume file specification for
+ * 'host' specifies the host where the volume file specification for
* the given volume resides. This can be either hostname, ipv4 address
* or ipv6 address. ipv6 address needs to be within square brackets [ ].
- * If transport type is 'unix', then 'server' field should not be specified.
+ * If transport type is 'unix', then 'host' field should not be specified.
* The 'socket' field needs to be populated with the path to unix domain
* socket.
*
@@ -90,9 +187,9 @@ static int parse_volume_options(GlusterConf *gconf, char
*path)
* default port. If the transport type is unix, then 'port' should not be
* specified.
*
- * 'volname' is the name of the gluster volume which contains the VM image.
+ * 'volume' is the name of the gluster volume which contains the VM image.
*
- * 'image' is the path to the actual VM image that resides on gluster volume.
+ * 'path' is the path to the actual VM image that resides on gluster volume.
*
* Examples:
*
@@ -105,28 +202,32 @@ static int parse_volume_options(GlusterConf *gconf, char
*path)
* file=gluster+unix:///testvol/dir/a.img?socket=/tmp/glusterd.socket
* file=gluster+rdma://1.2.3.4:24007/testvol/a.img
*/
-static int qemu_gluster_parseuri(GlusterConf *gconf, const char *filename)
+static int qemu_gluster_parseuri(GlusterConf **pgconf, const char *filename)
{
+ GlusterConf *gconf;
URI *uri;
QueryParams *qp = NULL;
bool is_unix = false;
- int ret = 0;
+ int ret;
uri = uri_parse(filename);
if (!uri) {
return -EINVAL;
}
+ gconf = g_new0(GlusterConf, 1);
+ gconf->gsconf = g_new0(GlusterServerConf, 1);
+
/* transport */
if (!uri->scheme || !strcmp(uri->scheme, "gluster")) {
- gconf->transport = g_strdup("tcp");
+ gconf->gsconf[0].transport = g_strdup("tcp");
} else if (!strcmp(uri->scheme, "gluster+tcp")) {
- gconf->transport = g_strdup("tcp");
+ gconf->gsconf[0].transport = g_strdup("tcp");
} else if (!strcmp(uri->scheme, "gluster+unix")) {
- gconf->transport = g_strdup("unix");
+ gconf->gsconf[0].transport = g_strdup("unix");
is_unix = true;
} else if (!strcmp(uri->scheme, "gluster+rdma")) {
- gconf->transport = g_strdup("rdma");
+ gconf->gsconf[0].transport = g_strdup("rdma");
} else {
ret = -EINVAL;
goto out;
@@ -152,12 +253,19 @@ static int qemu_gluster_parseuri(GlusterConf *gconf,
const char *filename)
ret = -EINVAL;
goto out;
}
- gconf->server = g_strdup(qp->p[0].value);
+ gconf->gsconf[0].host = g_strdup(qp->p[0].value);
} else {
- gconf->server = g_strdup(uri->server ? uri->server : "localhost");
- gconf->port = uri->port;
+ gconf->gsconf[0].host = g_strdup(uri->server ? uri->server :
"localhost");
+ if (uri->port) {
+ gconf->gsconf[0].port = uri->port;
+ } else {
+ gconf->gsconf[0].port = GLUSTER_DEFAULT_PORT;
+ }
+
}
+ *pgconf = gconf;
+
out:
if (qp) {
query_params_free(qp);
@@ -166,30 +274,35 @@ out:
return ret;
}
-static struct glfs *qemu_gluster_init(GlusterConf *gconf, const char *filename,
- Error **errp)
+static struct glfs *qemu_gluster_glfs_init(GlusterConf *gconf, int num_servers,
+ Error **errp)
{
- struct glfs *glfs = NULL;
- int ret;
+ struct glfs *glfs;
+ Error *local_err = NULL;
int old_errno;
+ int ret;
+ int i;
- ret = qemu_gluster_parseuri(gconf, filename);
- if (ret < 0) {
- error_setg(errp, "Usage: file=gluster[+transport]://[server[:port]]/"
- "volname/image[?socket=...]");
- errno = -ret;
- goto out;
- }
-
- glfs = glfs_new(gconf->volname);
+ glfs = glfs_new(gconf->volume);
if (!glfs) {
goto out;
}
- ret = glfs_set_volfile_server(glfs, gconf->transport, gconf->server,
- gconf->port);
- if (ret < 0) {
- goto out;
+ for (i = 0; i < num_servers; i++) {
+ ret = glfs_set_volfile_server(glfs, gconf->gsconf[i].transport,
+ gconf->gsconf[i].host,
+ gconf->gsconf[i].port);
+ if (ret < 0) {
+ goto out;
+ } else {
+ error_setg(&local_err, "INFO: Successfully set volume file server,
"
+ "server:'%s' port:'%d' trasport:'%s'",
+ gconf->gsconf[i].host,
+ gconf->gsconf[i].port,
+ gconf->gsconf[i].transport);
+ error_report_err(local_err);
+ local_err = NULL;
+ }
}
/*
@@ -203,11 +316,9 @@ static struct glfs *qemu_gluster_init(GlusterConf *gconf,
const char *filename,
ret = glfs_init(glfs);
if (ret) {
- error_setg_errno(errp, errno,
- "Gluster connection failed for server=%s port=%d "
- "volume=%s image=%s transport=%s", gconf->server,
- gconf->port, gconf->volname, gconf->image,
- gconf->transport);
+ error_setg_errno(errp, errno, "Error: Gluster connection failed for "
+ "given hosts volume:'%s' path='%s'",
+ gconf->volume, gconf->path);
/* glfs_init sometimes doesn't set errno although docs suggest that */
if (errno == 0)
@@ -215,6 +326,7 @@ static struct glfs *qemu_gluster_init(GlusterConf *gconf,
const char *filename,
goto out;
}
+
return glfs;
out:
@@ -226,6 +338,284 @@ out:
return NULL;
}
+static int parse_transport_option(const char *opt)
+{
+ int i;
+
+ if (!opt) {
+ /* Set tcp as default */
+ return GLUSTER_TRANSPORT_TCP;
+ }
+
+ for (i = 0; i < GLUSTER_TRANSPORT_MAX; i++) {
+ if (!strcmp(opt, GlusterTransport_lookup[i])) {
+ return i;
+ }
+ }
+
+ return -EINVAL;
+}
+
+/*
+*
+* Basic command line syntax looks like:
+*
+* Pattern I:
+* -drive driver=gluster,
+* volume=testvol,file.path=/path/a.raw,
+* servers.0.host=1.2.3.4,
+* [servers.0.port=24007,]
+* [servers.0.transport=tcp,]
+* servers.1.host=5.6.7.8,
+* [servers.1.port=24008,]
+* [servers.1.transport=rdma,] ...
+*
+* Pattern II:
+* 'json:{"driver":"qcow2","file":{"driver":"gluster",
+* "volume":"testvol","path":"/path/a.qcow2",
+* "servers":[{tuple0},{tuple1}, ...{tupleN}]}}'
+*
+*
+* driver => 'gluster' (protocol name)
+* volume => name of gluster volume where our VM image resides
+* path => absolute path of image in gluster volume
+*
+* {tuple} => {"host":"1.2.3.4"[,"port":"24007","transport":"tcp"]}
+*
+* host => host address (hostname/ipv4/ipv6 addresses)
+* port => port number on which glusterd is listening. (default 24007)
+* tranport => transport type used to connect to gluster management daemon,
+* it can be tcp|rdma (default 'tcp')
+*
+*
+* Examples:
+* Pattern I:
+* -drive driver=qcow2,file.driver=gluster,
+* file.volume=testvol,file.path=/path/a.qcow2,
+* file.servers.0.host=1.2.3.4,
+* file.servers.0.port=24007,
+* file.servers.0.transport=tcp,
+* file.servers.1.host=5.6.7.8,
+* file.servers.1.port=24008,
+* file.servers.1.transport=rdma, ...
+*
+* -drive driver=qcow2,file.driver=gluster,
+* file.volume=testvol,file.path=/path/a.qcow2,
+* file.servers.0.host=1.2.3.4,
+* file.servers.1.host=5.6.7.8, ...
+*
+* -drive driver=qcow2,file.driver=gluster,
+* file.volume=testvol,file.path=/path/a.qcow2,
+* file.servers.0.host=1.2.3.4,
+* file.servers.0.port=24007,
+* file.servers.1.host=5.6.7.8,
+* file.servers.1.port=24008, ...
+*
+* -drive driver=qcow2,file.driver=gluster,
+* file.volume=testvol,file.path=/path/a.qcow2,
+* file.servers.0.host=1.2.3.4,
+* file.servers.0.transport=tcp,
+* file.servers.1.host=5.6.7.8,
+* file.servers.1.transport=rdma, ...
+*
+* Pattern II:
+* 'json:{"driver":"qcow2","file":{"driver":"gluster","volume":"testvol",
+* "path":"/path/a.qcow2","servers":
+* [{"host":"1.2.3.4","port":"24007","transport":"tcp"},
+* {"host":"4.5.6.7","port":"24008","transport":"rdma"}, ...]}}'
+*
+* 'json:{"driver":"qcow2","file":{"driver":"gluster","volume":"testvol",
+* "path":"/path/a.qcow2","servers":
+* [{"host":"1.2.3.4"},
+* {"host":"4.5.6.7"}, ...]}}'
+*
+*
+* 'json:{"driver":"qcow2","file":{"driver":"gluster","volume":"testvol",
+* "path":"/path/a.qcow2","servers":
+* [{"host":"1.2.3.4","port":"24007"},
+* {"host":"4.5.6.7","port":"24008"}, ...]}}'
+*
+*
+* 'json:{"driver":"qcow2","file":{"driver":"gluster","volume":"testvol",
+* "path":"/path/a.qcow2","servers":
+* [{"host":"1.2.3.4","transport":"tcp"},
+* {"host":"4.5.6.7","transport":"rdma"}, ...]}}'
+*
+* Just for better readability pattern II is kept as:
+* json:
+* {
+* "driver":"qcow2",
+* "file":{
+* "driver":"gluster",
+* "volume":"testvol",
+* "path":"/path/a.qcow2",
+* "servers":[
+* {
+* "host":"1.2.3.4",
+* "port":"24007",
+* "transport":"tcp"
+* },
+* {
+* "host":"5.6.7.8",
+* "port":"24008",
+* "transport":"rdma"
+* }
+* ]
+* }
+* }
+*
+*/
+static int qemu_gluster_parsejson(GlusterConf **pgconf, QDict *options)
+{
+ QemuOpts *opts;
+ GlusterConf *gconf = NULL;
+ QDict *backing_options = NULL;
+ Error *local_err = NULL;
+ const char *transport;
+ char *str = NULL;
+ int num_servers;
+ int ret = 0;
+ int i;
+
+ /* create opts info from runtime_json_opts list */
+ opts = qemu_opts_create(&runtime_json_opts, NULL, 0, &error_abort);
+ qemu_opts_absorb_qdict(opts, options, &local_err);
+ if (local_err) {
+ goto out;
+ }
+ num_servers = qdict_array_entries(options, GLUSTER_OPT_SERVER_PATTERN);
+ if (num_servers < 1) {
+ error_setg(&local_err, "Error: qemu_gluster: please provide 'servers' "
+ "option with valid fields in array of tuples");
+ goto out;
+ }
+
+ gconf = g_new0(GlusterConf, 1);
+ gconf->gsconf = g_new0(GlusterServerConf, num_servers);
+
+ gconf->volume = (char *) qemu_opt_get(opts, GLUSTER_OPT_VOLUME);
+ if (!gconf->volume) {
+ error_setg(&local_err, "Error: qemu_gluster: please provide 'volume' "
+ "option");
+ goto out;
+ }
+
+ gconf->path = (char *) qemu_opt_get(opts, GLUSTER_OPT_PATH);
+ if (!gconf->path) {
+ error_setg(&local_err, "Error: qemu_gluster: please provide 'path' "
+ "option");
+ goto out;
+ }
+
+ /* create opts info from runtime_tuple_opts list */
+ opts = qemu_opts_create(&runtime_tuple_opts, NULL, 0, &error_abort);
+ str = g_malloc(40);
+ for (i = 0; i < num_servers; i++) {
+ snprintf(str, 40, GLUSTER_OPT_SERVER_PATTERN"%d.", i);
+ qdict_extract_subqdict(options, &backing_options, str);
+ qemu_opts_absorb_qdict(opts, backing_options, &local_err);
+ if (local_err) {
+ goto out;
+ }
+
+ gconf->gsconf[i].host = (char *) qemu_opt_get(opts, GLUSTER_OPT_HOST);
+ if (!gconf->gsconf[i].host) {
+ error_setg(&local_err, "Error: qemu_gluster: servers.{tuple.%d} "
+ "requires 'host' option", i);
+ goto out;
+ }
+
+ transport = qemu_opt_get(opts, GLUSTER_OPT_TRANSPORT);
+ if (!transport) {
+ transport = GLUSTER_DEFAULT_TRANSPORT;
+ }
+ /* check whether transport type specified in json command is valid */
+ ret = parse_transport_option(transport);
+ if (ret < 0) {
+ error_setg(&local_err, "Error: qemu_gluster: please set
'transport'"
+ " type in tuple.%d as tcp or rdma", i);
+ goto out;
+ } else {
+ /* only if valid transport i.e. either of tcp|rdma is specified */
+ gconf->gsconf[i].transport = (char *) transport;
+ }
+
+ gconf->gsconf[i].port = qemu_opt_get_number(opts, GLUSTER_OPT_PORT,
+ GLUSTER_DEFAULT_PORT);
+
+ /*
+ * reset current tuple opts to NULL/0, so that in case if the next
tuple
+ * misses any of (host, tranport, port) options there is no chance of
+ * copying from current set.
+ */
+ qemu_opt_set(opts, GLUSTER_OPT_HOST, NULL, &error_abort);
+ qemu_opt_set_number(opts, GLUSTER_OPT_PORT,
+ GLUSTER_DEFAULT_PORT, &error_abort);
+ qemu_opt_set(opts, GLUSTER_OPT_TRANSPORT, NULL, &error_abort);
+ }
+
+ *pgconf = gconf;
+ g_free(str);
+ return num_servers;
+
+out:
+ error_report_err(local_err);
+ g_free(str);
+ g_free(gconf->gsconf);
+ g_free(gconf);
+ gconf->gsconf = NULL;
+ gconf = NULL;
+ errno = EINVAL;
+ qemu_opts_del(opts);
+ return -EINVAL;
+}
+
+static struct glfs *qemu_gluster_init(GlusterConf **gconf, const char
*filename,
+ QDict *options, Error **errp)
+{
+ int ret;
+ int num_servers;
+
+ if (filename) {
+ ret = qemu_gluster_parseuri(gconf, filename);
+ if (ret < 0) {
+ error_setg(errp, "Usage: file=gluster[+transport]://[host[:port]]/"
+ "volume/path[?socket=...]");
+ errno = -ret;
+ goto out;
+ }
+ } else {
+ num_servers = qemu_gluster_parsejson(gconf, options);
+ if (num_servers < 1) {
+ error_setg(errp, "#Usage1: "
+ "-drive driver=qcow2,file.driver=gluster,"
+ "file.volume=testvol,file.path=/path/a.qcow2,"
+ "file.servers.0.host=1.2.3.4,"
+ "[file.servers.0.port=24007,]"
+ "[file.servers.0.transport=tcp,]"
+ "file.servers.1.host=5.6.7.8,"
+ "[file.servers.1.port=24008,]"
+ "[file.servers.1.transport=rdma,] ..."
+ "\n#Usage2: "
+ "'json:{\"driver\":\"qcow2\",\"file\":"
+ "{\"driver\":\"gluster\",\"volume\":\""
+ "testvol\",\"path\":\"/path/a.qcow2\","
+ "\"servers\":[{\"host\":\"1.2.3.4\","
+ "\"port\":\"24007\",\"transport\":\"tcp\"},"
+ "{\"host\":\"4.5.6.7\",\"port\":\"24007\","
+ "\"transport\":\"rdma\"}, ...]}}'");
+ errno = -num_servers;
+ goto out;
+ }
+ }
+
+ return qemu_gluster_glfs_init(*gconf, num_servers, errp);
+
+out:
+
+ return NULL;
+}
+
static void qemu_gluster_complete_aio(void *opaque)
{
GlusterAIOCB *acb = (GlusterAIOCB *)opaque;
@@ -254,20 +644,6 @@ static void gluster_finish_aiocb(struct glfs_fd *fd,
ssize_t ret, void *arg)
qemu_bh_schedule(acb->bh);
}
-/* TODO Convert to fine grained options */
-static QemuOptsList runtime_opts = {
- .name = "gluster",
- .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
- .desc = {
- {
- .name = "filename",
- .type = QEMU_OPT_STRING,
- .help = "URL to the gluster image",
- },
- { /* end of list */ }
- },
-};
-
static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags)
{
assert(open_flags != NULL);
@@ -291,11 +667,12 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict
*options,
BDRVGlusterState *s = bs->opaque;
int open_flags = 0;
int ret = 0;
- GlusterConf *gconf = g_new0(GlusterConf, 1);
+ GlusterConf *gconf = NULL;
QemuOpts *opts;
Error *local_err = NULL;
const char *filename;
+ qdict_flatten(options);
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
@@ -306,7 +683,7 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict
*options,
filename = qemu_opt_get(opts, "filename");
- s->glfs = qemu_gluster_init(gconf, filename, errp);
+ s->glfs = qemu_gluster_init(&gconf, filename, options, errp);
if (!s->glfs) {
ret = -errno;
goto out;
@@ -314,14 +691,19 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict
*options,
qemu_gluster_parse_flags(bdrv_flags, &open_flags);
- s->fd = glfs_open(s->glfs, gconf->image, open_flags);
+ s->fd = glfs_open(s->glfs, gconf->path, open_flags);
if (!s->fd) {
ret = -errno;
}
out:
qemu_opts_del(opts);
- qemu_gluster_gconf_free(gconf);
+ if (filename) {
+ qemu_gluster_gconf_free(gconf);
+ } else if (gconf) {
+ g_free(gconf->gsconf);
+ g_free(gconf);
+ }
if (!ret) {
return ret;
}
@@ -334,12 +716,6 @@ out:
return ret;
}
-typedef struct BDRVGlusterReopenState {
- struct glfs *glfs;
- struct glfs_fd *fd;
-} BDRVGlusterReopenState;
-
-
static int qemu_gluster_reopen_prepare(BDRVReopenState *state,
BlockReopenQueue *queue, Error **errp)
{
@@ -356,15 +732,13 @@ static int qemu_gluster_reopen_prepare(BDRVReopenState
*state,
qemu_gluster_parse_flags(state->flags, &open_flags);
- gconf = g_new0(GlusterConf, 1);
-
- reop_s->glfs = qemu_gluster_init(gconf, state->bs->filename, errp);
+ reop_s->glfs = qemu_gluster_init(&gconf, state->bs->filename, NULL, errp);
if (reop_s->glfs == NULL) {
ret = -errno;
goto exit;
}
- reop_s->fd = glfs_open(reop_s->glfs, gconf->image, open_flags);
+ reop_s->fd = glfs_open(reop_s->glfs, gconf->path, open_flags);
if (reop_s->fd == NULL) {
/* reops->glfs will be cleaned up in _abort */
ret = -errno;
@@ -401,7 +775,6 @@ static void qemu_gluster_reopen_commit(BDRVReopenState
*state)
return;
}
-
static void qemu_gluster_reopen_abort(BDRVReopenState *state)
{
BDRVGlusterReopenState *reop_s = state->opaque;
@@ -480,15 +853,15 @@ static inline int qemu_gluster_zerofill(struct glfs_fd
*fd, int64_t offset,
static int qemu_gluster_create(const char *filename,
QemuOpts *opts, Error **errp)
{
+ GlusterConf *gconf = NULL;
struct glfs *glfs;
struct glfs_fd *fd;
int ret = 0;
int prealloc = 0;
int64_t total_size = 0;
char *tmp = NULL;
- GlusterConf *gconf = g_new0(GlusterConf, 1);
- glfs = qemu_gluster_init(gconf, filename, errp);
+ glfs = qemu_gluster_init(&gconf, filename, NULL, errp);
if (!glfs) {
ret = -errno;
goto out;
@@ -504,14 +877,14 @@ static int qemu_gluster_create(const char *filename,
gluster_supports_zerofill()) {
prealloc = 1;
} else {
- error_setg(errp, "Invalid preallocation mode: '%s'"
- " or GlusterFS doesn't support zerofill API",
- tmp);
+ error_setg(errp, "Error: Invalid preallocation mode: '%s'"
+ " or GlusterFS doesn't support zerofill API",
+ tmp);
ret = -EINVAL;
goto out;
}
- fd = glfs_creat(glfs, gconf->image,
+ fd = glfs_creat(glfs, gconf->path,
O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR);
if (!fd) {
ret = -errno;
@@ -696,29 +1069,11 @@ static int qemu_gluster_has_zero_init(BlockDriverState
*bs)
return 0;
}
-static QemuOptsList qemu_gluster_create_opts = {
- .name = "qemu-gluster-create-opts",
- .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head),
- .desc = {
- {
- .name = BLOCK_OPT_SIZE,
- .type = QEMU_OPT_SIZE,
- .help = "Virtual disk size"
- },
- {
- .name = BLOCK_OPT_PREALLOC,
- .type = QEMU_OPT_STRING,
- .help = "Preallocation mode (allowed values: off, full)"
- },
- { /* end of list */ }
- }
-};
-
static BlockDriver bdrv_gluster = {
.format_name = "gluster",
.protocol_name = "gluster",
.instance_size = sizeof(BDRVGlusterState),
- .bdrv_needs_filename = true,
+ .bdrv_needs_filename = false,
.bdrv_file_open = qemu_gluster_open,
.bdrv_reopen_prepare = qemu_gluster_reopen_prepare,
.bdrv_reopen_commit = qemu_gluster_reopen_commit,
@@ -745,7 +1100,7 @@ static BlockDriver bdrv_gluster_tcp = {
.format_name = "gluster",
.protocol_name = "gluster+tcp",
.instance_size = sizeof(BDRVGlusterState),
- .bdrv_needs_filename = true,
+ .bdrv_needs_filename = false,
.bdrv_file_open = qemu_gluster_open,
.bdrv_reopen_prepare = qemu_gluster_reopen_prepare,
.bdrv_reopen_commit = qemu_gluster_reopen_commit,
@@ -799,7 +1154,7 @@ static BlockDriver bdrv_gluster_rdma = {
.format_name = "gluster",
.protocol_name = "gluster+rdma",
.instance_size = sizeof(BDRVGlusterState),
- .bdrv_needs_filename = true,
+ .bdrv_needs_filename = false,
.bdrv_file_open = qemu_gluster_open,
.bdrv_reopen_prepare = qemu_gluster_reopen_prepare,
.bdrv_reopen_commit = qemu_gluster_reopen_commit,
diff --git a/qapi/block-core.json b/qapi/block-core.json
index bb2189e..8bc69e0 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -1380,10 +1380,10 @@
##
{ 'enum': 'BlockdevDriver',
'data': [ 'archipelago', 'blkdebug', 'blkverify', 'bochs', 'cloop',
- 'dmg', 'file', 'ftp', 'ftps', 'host_cdrom', 'host_device',
- 'host_floppy', 'http', 'https', 'null-aio', 'null-co', 'parallels',
- 'qcow', 'qcow2', 'qed', 'quorum', 'raw', 'tftp', 'vdi', 'vhdx',
- 'vmdk', 'vpc', 'vvfat' ] }
+ 'dmg', 'file', 'ftp', 'ftps', 'gluster', 'host_cdrom',
+ 'host_device', 'host_floppy', 'http', 'https', 'null-aio',
+ 'null-co', 'parallels', 'qcow', 'qcow2', 'qed', 'quorum', 'raw',
+ 'tftp', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
##
# @BlockdevOptionsBase
@@ -1794,6 +1794,56 @@
'*read-pattern': 'QuorumReadPattern' } }
##
+# @GlusterTransport
+#
+# An enumeration of Gluster transport type
+#
+# @tcp: TCP - Transmission Control Protocol
+#
+# @rdma: RDMA - Remote direct memory access
+#
+# Since: 2.5
+##
+{ 'enum': 'GlusterTransport', 'data': [ 'tcp', 'rdma' ] }
+
+##
+# @GlusterTuple
+#
+# Gluster tuple set
+#
+# @host: host address (hostname/ipv4/ipv6 addresses)
+#
+# @port: port number on which glusterd is listening. (default 24007)
+#
+# @transport: #transport type used to connect to gluster management daemon
+# it can be tcp|rdma (default 'tcp')
+#
+# Since: 2.5
+##
+{ 'struct': 'GlusterTuple',
+ 'data': { 'host': 'str',
+ '*port': 'int',
+ '*transport': 'GlusterTransport' } }
+
+##
+# @BlockdevOptionsGluster
+#
+# Driver specific block device options for Gluster
+#
+# @volume: name of gluster volume where our VM image resides
+#
+# @path: absolute path to image file in gluster volume
+#
+# @servers: holds multiple tuples of {host, transport, port}
+#
+# Since: 2.5
+##
+{ 'struct': 'BlockdevOptionsGluster',
+ 'data': { 'volume': 'str',
+ 'path': 'str',
+ 'servers': [ 'GlusterTuple' ] } }
+
+##
# @BlockdevOptions
#
# Options for creating a block device.
@@ -1813,7 +1863,7 @@
'file': 'BlockdevOptionsFile',
'ftp': 'BlockdevOptionsFile',
'ftps': 'BlockdevOptionsFile',
-# TODO gluster: Wait for structured options
+ 'gluster': 'BlockdevOptionsGluster',
'host_cdrom': 'BlockdevOptionsFile',
'host_device':'BlockdevOptionsFile',
'host_floppy':'BlockdevOptionsFile',
--
2.1.0
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Qemu-devel] [PATCH v6 1/1] block/gluster: add support for multiple gluster backup volfile servers,
Prasanna Kumar Kalever <=