block: Drop unmaintained 'archipelago' driver

[qemu.git] / block / gluster.c

diff --git a/block/gluster.c b/block/gluster.c
index 1a22f2982d33c52df044230fa1784eef4eaa77cd..a577daef10ac9bc14017c94835aa2e997b1c97cb 100644 (file)
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -12,6 +12,7 @@
 #include "block/block_int.h"
 #include "qapi/error.h"
 #include "qapi/qmp/qerror.h"
 #include "block/block_int.h"
 #include "qapi/error.h"
 #include "qapi/qmp/qerror.h"

+#include "qapi/util.h"

 #include "qemu/uri.h"
 #include "qemu/error-report.h"
 #include "qemu/cutils.h"
 #include "qemu/uri.h"
 #include "qemu/error-report.h"
 #include "qemu/cutils.h"


@@ -151,7 +152,7 @@ static QemuOptsList runtime_type_opts = {
         {
             .name = GLUSTER_OPT_TYPE,
             .type = QEMU_OPT_STRING,
         {
             .name = GLUSTER_OPT_TYPE,
             .type = QEMU_OPT_STRING,

-            .help = "tcp|unix",
+            .help = "inet|unix",

         },
         { /* end of list */ }
     },
         },
         { /* end of list */ }
     },


@@ -170,14 +171,14 @@ static QemuOptsList runtime_unix_opts = {
     },
 };
 
     },
 };
 

-static QemuOptsList runtime_tcp_opts = {
-    .name = "gluster_tcp",
-    .head = QTAILQ_HEAD_INITIALIZER(runtime_tcp_opts.head),
+static QemuOptsList runtime_inet_opts = {
+    .name = "gluster_inet",
+    .head = QTAILQ_HEAD_INITIALIZER(runtime_inet_opts.head),

     .desc = {
         {
             .name = GLUSTER_OPT_TYPE,
             .type = QEMU_OPT_STRING,
     .desc = {
         {
             .name = GLUSTER_OPT_TYPE,
             .type = QEMU_OPT_STRING,

-            .help = "tcp|unix",
+            .help = "inet|unix",

         },
         {
             .name = GLUSTER_OPT_HOST,
         },
         {
             .name = GLUSTER_OPT_HOST,


@@ -320,7 +321,7 @@ static int parse_volume_options(BlockdevOptionsGluster *gconf, char *path)
 static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf,
                                   const char *filename)
 {
 static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf,
                                   const char *filename)
 {

-    GlusterServer *gsconf;
+    SocketAddressFlat *gsconf;

     URI *uri;
     QueryParams *qp = NULL;
     bool is_unix = false;
     URI *uri;
     QueryParams *qp = NULL;
     bool is_unix = false;


@@ -331,19 +332,19 @@ static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf,
         return -EINVAL;
     }
 
         return -EINVAL;
     }
 

-    gconf->server = g_new0(GlusterServerList, 1);
-    gconf->server->value = gsconf = g_new0(GlusterServer, 1);
+    gconf->server = g_new0(SocketAddressFlatList, 1);
+    gconf->server->value = gsconf = g_new0(SocketAddressFlat, 1);

 
     /* transport */
     if (!uri->scheme || !strcmp(uri->scheme, "gluster")) {
 
     /* transport */
     if (!uri->scheme || !strcmp(uri->scheme, "gluster")) {

-        gsconf->type = GLUSTER_TRANSPORT_TCP;
+        gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_INET;

     } else if (!strcmp(uri->scheme, "gluster+tcp")) {
     } else if (!strcmp(uri->scheme, "gluster+tcp")) {

-        gsconf->type = GLUSTER_TRANSPORT_TCP;
+        gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_INET;

     } else if (!strcmp(uri->scheme, "gluster+unix")) {
     } else if (!strcmp(uri->scheme, "gluster+unix")) {

-        gsconf->type = GLUSTER_TRANSPORT_UNIX;
+        gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_UNIX;

         is_unix = true;
     } else if (!strcmp(uri->scheme, "gluster+rdma")) {
         is_unix = true;
     } else if (!strcmp(uri->scheme, "gluster+rdma")) {

-        gsconf->type = GLUSTER_TRANSPORT_TCP;
+        gsconf->type = SOCKET_ADDRESS_FLAT_TYPE_INET;

         error_report("Warning: rdma feature is not supported, falling "
                      "back to tcp");
     } else {
         error_report("Warning: rdma feature is not supported, falling "
                      "back to tcp");
     } else {


@@ -373,11 +374,11 @@ static int qemu_gluster_parse_uri(BlockdevOptionsGluster *gconf,
         }
         gsconf->u.q_unix.path = g_strdup(qp->p[0].value);
     } else {
         }
         gsconf->u.q_unix.path = g_strdup(qp->p[0].value);
     } else {

-        gsconf->u.tcp.host = g_strdup(uri->server ? uri->server : "localhost");
+        gsconf->u.inet.host = g_strdup(uri->server ? uri->server : "localhost");

         if (uri->port) {
         if (uri->port) {

-            gsconf->u.tcp.port = g_strdup_printf("%d", uri->port);
+            gsconf->u.inet.port = g_strdup_printf("%d", uri->port);

         } else {
         } else {

-            gsconf->u.tcp.port = g_strdup_printf("%d", GLUSTER_DEFAULT_PORT);
+            gsconf->u.inet.port = g_strdup_printf("%d", GLUSTER_DEFAULT_PORT);

         }
     }
 
         }
     }
 


@@ -395,7 +396,7 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
     struct glfs *glfs;
     int ret;
     int old_errno;
     struct glfs *glfs;
     int ret;
     int old_errno;

-    GlusterServerList *server;
+    SocketAddressFlatList *server;

     unsigned long long port;
 
     glfs = glfs_find_preopened(gconf->volume);
     unsigned long long port;
 
     glfs = glfs_find_preopened(gconf->volume);


@@ -411,21 +412,19 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
     glfs_set_preopened(gconf->volume, glfs);
 
     for (server = gconf->server; server; server = server->next) {
     glfs_set_preopened(gconf->volume, glfs);
 
     for (server = gconf->server; server; server = server->next) {

-        if (server->value->type  == GLUSTER_TRANSPORT_UNIX) {
-            ret = glfs_set_volfile_server(glfs,
-                                   GlusterTransport_lookup[server->value->type],
+        if (server->value->type  == SOCKET_ADDRESS_FLAT_TYPE_UNIX) {
+            ret = glfs_set_volfile_server(glfs, "unix",

                                    server->value->u.q_unix.path, 0);
         } else {
                                    server->value->u.q_unix.path, 0);
         } else {

-            if (parse_uint_full(server->value->u.tcp.port, &port, 10) < 0 ||
+            if (parse_uint_full(server->value->u.inet.port, &port, 10) < 0 ||

                 port > 65535) {
                 error_setg(errp, "'%s' is not a valid port number",
                 port > 65535) {
                 error_setg(errp, "'%s' is not a valid port number",

-                           server->value->u.tcp.port);
+                           server->value->u.inet.port);

                 errno = EINVAL;
                 goto out;
             }
                 errno = EINVAL;
                 goto out;
             }

-            ret = glfs_set_volfile_server(glfs,
-                                   GlusterTransport_lookup[server->value->type],
-                                   server->value->u.tcp.host,
+            ret = glfs_set_volfile_server(glfs, "tcp",
+                                   server->value->u.inet.host,

                                    (int)port);
         }
 
                                    (int)port);
         }
 


@@ -444,13 +443,13 @@ static struct glfs *qemu_gluster_glfs_init(BlockdevOptionsGluster *gconf,
         error_setg(errp, "Gluster connection for volume %s, path %s failed"
                          " to connect", gconf->volume, gconf->path);
         for (server = gconf->server; server; server = server->next) {
         error_setg(errp, "Gluster connection for volume %s, path %s failed"
                          " to connect", gconf->volume, gconf->path);
         for (server = gconf->server; server; server = server->next) {

-            if (server->value->type  == GLUSTER_TRANSPORT_UNIX) {
+            if (server->value->type  == SOCKET_ADDRESS_FLAT_TYPE_UNIX) {

                 error_append_hint(errp, "hint: failed on socket %s ",
                                   server->value->u.q_unix.path);
             } else {
                 error_append_hint(errp, "hint: failed on host %s and port %s ",
                 error_append_hint(errp, "hint: failed on socket %s ",
                                   server->value->u.q_unix.path);
             } else {
                 error_append_hint(errp, "hint: failed on host %s and port %s ",

-                                  server->value->u.tcp.host,
-                                  server->value->u.tcp.port);
+                                  server->value->u.inet.host,
+                                  server->value->u.inet.port);

             }
         }
 
             }
         }
 


@@ -474,23 +473,6 @@ out:
     return NULL;
 }
 
     return NULL;
 }
 

-static int qapi_enum_parse(const char *opt)
-{
-    int i;
-
-    if (!opt) {
-        return GLUSTER_TRANSPORT__MAX;
-    }
-
-    for (i = 0; i < GLUSTER_TRANSPORT__MAX; i++) {
-        if (!strcmp(opt, GlusterTransport_lookup[i])) {
-            return i;
-        }
-    }
-
-    return i;
-}
-

 /*
  * Convert the json formatted command line into qapi.
 */
 /*
  * Convert the json formatted command line into qapi.
 */


@@ -498,8 +480,8 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
                                   QDict *options, Error **errp)
 {
     QemuOpts *opts;
                                   QDict *options, Error **errp)
 {
     QemuOpts *opts;

-    GlusterServer *gsconf;
-    GlusterServerList *curr = NULL;
+    SocketAddressFlat *gsconf = NULL;
+    SocketAddressFlatList *curr = NULL;

     QDict *backing_options = NULL;
     Error *local_err = NULL;
     char *str = NULL;
     QDict *backing_options = NULL;
     Error *local_err = NULL;
     char *str = NULL;


@@ -547,25 +529,31 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
         }
 
         ptr = qemu_opt_get(opts, GLUSTER_OPT_TYPE);
         }
 
         ptr = qemu_opt_get(opts, GLUSTER_OPT_TYPE);

-        gsconf = g_new0(GlusterServer, 1);
-        gsconf->type = qapi_enum_parse(ptr);

         if (!ptr) {
             error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_TYPE);
             error_append_hint(&local_err, GERR_INDEX_HINT, i);
             goto out;
 
         }
         if (!ptr) {
             error_setg(&local_err, QERR_MISSING_PARAMETER, GLUSTER_OPT_TYPE);
             error_append_hint(&local_err, GERR_INDEX_HINT, i);
             goto out;
 
         }

-        if (gsconf->type == GLUSTER_TRANSPORT__MAX) {
-            error_setg(&local_err, QERR_INVALID_PARAMETER_VALUE,
-                       GLUSTER_OPT_TYPE, "tcp or unix");
+        gsconf = g_new0(SocketAddressFlat, 1);
+        if (!strcmp(ptr, "tcp")) {
+            ptr = "inet";       /* accept legacy "tcp" */
+        }
+        gsconf->type = qapi_enum_parse(SocketAddressFlatType_lookup, ptr,
+                                       SOCKET_ADDRESS_FLAT_TYPE__MAX, -1,
+                                       &local_err);
+        if (local_err) {
+            error_append_hint(&local_err,
+                              "Parameter '%s' may be 'inet' or 'unix'\n",
+                              GLUSTER_OPT_TYPE);

             error_append_hint(&local_err, GERR_INDEX_HINT, i);
             goto out;
         }
         qemu_opts_del(opts);
 
             error_append_hint(&local_err, GERR_INDEX_HINT, i);
             goto out;
         }
         qemu_opts_del(opts);
 

-        if (gsconf->type == GLUSTER_TRANSPORT_TCP) {
-            /* create opts info from runtime_tcp_opts list */
-            opts = qemu_opts_create(&runtime_tcp_opts, NULL, 0, &error_abort);
+        if (gsconf->type == SOCKET_ADDRESS_FLAT_TYPE_INET) {
+            /* create opts info from runtime_inet_opts list */
+            opts = qemu_opts_create(&runtime_inet_opts, NULL, 0, &error_abort);

             qemu_opts_absorb_qdict(opts, backing_options, &local_err);
             if (local_err) {
                 goto out;
             qemu_opts_absorb_qdict(opts, backing_options, &local_err);
             if (local_err) {
                 goto out;


@@ -578,7 +566,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
                 error_append_hint(&local_err, GERR_INDEX_HINT, i);
                 goto out;
             }
                 error_append_hint(&local_err, GERR_INDEX_HINT, i);
                 goto out;
             }

-            gsconf->u.tcp.host = g_strdup(ptr);
+            gsconf->u.inet.host = g_strdup(ptr);

             ptr = qemu_opt_get(opts, GLUSTER_OPT_PORT);
             if (!ptr) {
                 error_setg(&local_err, QERR_MISSING_PARAMETER,
             ptr = qemu_opt_get(opts, GLUSTER_OPT_PORT);
             if (!ptr) {
                 error_setg(&local_err, QERR_MISSING_PARAMETER,


@@ -586,28 +574,28 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
                 error_append_hint(&local_err, GERR_INDEX_HINT, i);
                 goto out;
             }
                 error_append_hint(&local_err, GERR_INDEX_HINT, i);
                 goto out;
             }

-            gsconf->u.tcp.port = g_strdup(ptr);
+            gsconf->u.inet.port = g_strdup(ptr);

 
             /* defend for unsupported fields in InetSocketAddress,
              * i.e. @ipv4, @ipv6  and @to
              */
             ptr = qemu_opt_get(opts, GLUSTER_OPT_TO);
             if (ptr) {
 
             /* defend for unsupported fields in InetSocketAddress,
              * i.e. @ipv4, @ipv6  and @to
              */
             ptr = qemu_opt_get(opts, GLUSTER_OPT_TO);
             if (ptr) {

-                gsconf->u.tcp.has_to = true;
+                gsconf->u.inet.has_to = true;

             }
             ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV4);
             if (ptr) {
             }
             ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV4);
             if (ptr) {

-                gsconf->u.tcp.has_ipv4 = true;
+                gsconf->u.inet.has_ipv4 = true;

             }
             ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV6);
             if (ptr) {
             }
             ptr = qemu_opt_get(opts, GLUSTER_OPT_IPV6);
             if (ptr) {

-                gsconf->u.tcp.has_ipv6 = true;
+                gsconf->u.inet.has_ipv6 = true;

             }
             }

-            if (gsconf->u.tcp.has_to) {
+            if (gsconf->u.inet.has_to) {

                 error_setg(&local_err, "Parameter 'to' not supported");
                 goto out;
             }
                 error_setg(&local_err, "Parameter 'to' not supported");
                 goto out;
             }

-            if (gsconf->u.tcp.has_ipv4 || gsconf->u.tcp.has_ipv6) {
+            if (gsconf->u.inet.has_ipv4 || gsconf->u.inet.has_ipv6) {

                 error_setg(&local_err, "Parameters 'ipv4/ipv6' not supported");
                 goto out;
             }
                 error_setg(&local_err, "Parameters 'ipv4/ipv6' not supported");
                 goto out;
             }


@@ -632,16 +620,18 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
         }
 
         if (gconf->server == NULL) {
         }
 
         if (gconf->server == NULL) {

-            gconf->server = g_new0(GlusterServerList, 1);
+            gconf->server = g_new0(SocketAddressFlatList, 1);

             gconf->server->value = gsconf;
             curr = gconf->server;
         } else {
             gconf->server->value = gsconf;
             curr = gconf->server;
         } else {

-            curr->next = g_new0(GlusterServerList, 1);
+            curr->next = g_new0(SocketAddressFlatList, 1);

             curr->next->value = gsconf;
             curr = curr->next;
         }
             curr->next->value = gsconf;
             curr = curr->next;
         }

+        gsconf = NULL;

 
 

-        qdict_del(backing_options, str);
+        QDECREF(backing_options);
+        backing_options = NULL;

         g_free(str);
         str = NULL;
     }
         g_free(str);
         str = NULL;
     }


@@ -650,11 +640,10 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
 
 out:
     error_propagate(errp, local_err);
 
 out:
     error_propagate(errp, local_err);

+    qapi_free_SocketAddressFlat(gsconf);

     qemu_opts_del(opts);
     qemu_opts_del(opts);

-    if (str) {
-        qdict_del(backing_options, str);
-        g_free(str);
-    }
+    g_free(str);
+    QDECREF(backing_options);

     errno = EINVAL;
     return -errno;
 }
     errno = EINVAL;
     return -errno;
 }


@@ -683,7 +672,7 @@ static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf,
                              "file.volume=testvol,file.path=/path/a.qcow2"
                              "[,file.debug=9]"
                              "[,file.logfile=/path/filename.log],"
                              "file.volume=testvol,file.path=/path/a.qcow2"
                              "[,file.debug=9]"
                              "[,file.logfile=/path/filename.log],"

-                             "file.server.0.type=tcp,"
+                             "file.server.0.type=inet,"

                              "file.server.0.host=1.2.3.4,"
                              "file.server.0.port=24007,"
                              "file.server.1.transport=unix,"
                              "file.server.0.host=1.2.3.4,"
                              "file.server.0.port=24007,"
                              "file.server.1.transport=unix,"


@@ -698,13 +687,6 @@ static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf,
     return qemu_gluster_glfs_init(gconf, errp);
 }
 
     return qemu_gluster_glfs_init(gconf, errp);
 }
 

-static void qemu_gluster_complete_aio(void *opaque)
-{
-    GlusterAIOCB *acb = (GlusterAIOCB *)opaque;
-
-    qemu_coroutine_enter(acb->coroutine);
-}
-

 /*
  * AIO callback routine called from GlusterFS thread.
  */
 /*
  * AIO callback routine called from GlusterFS thread.
  */


@@ -720,7 +702,7 @@ static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg)
         acb->ret = -EIO; /* Partial read/write - fail it */
     }
 
         acb->ret = -EIO; /* Partial read/write - fail it */
     }
 

-    aio_bh_schedule_oneshot(acb->aio_context, qemu_gluster_complete_aio, acb);
+    aio_co_schedule(acb->aio_context, acb->coroutine);

 }
 
 static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags)
 }
 
 static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags)