block: Make bdrv_attach/detach_aio_context() static

[qemu.git] / block / vxhs.c

diff --git a/block/vxhs.c b/block/vxhs.c
index 9ffe9d38148cd96b91ef834b3a39c847bb2c2f86..2e18229ba44897804c60185cb42abe99712db0d0 100644 (file)
--- a/block/vxhs.c
+++ b/block/vxhs.c
@@ -12,6 +12,7 @@
 #include <qnio/qnio_api.h>
 #include <sys/param.h>
 #include "block/block_int.h"
 #include <qnio/qnio_api.h>
 #include <sys/param.h>
 #include "block/block_int.h"

+#include "block/qdict.h"

 #include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qstring.h"
 #include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qstring.h"


@@ -182,15 +183,15 @@ static int vxhs_parse_uri(const char *filename, QDict *options)
         return -EINVAL;
     }
 
         return -EINVAL;
     }
 

-    qdict_put(options, VXHS_OPT_SERVER".host", qstring_from_str(uri->server));
+    qdict_put_str(options, VXHS_OPT_SERVER ".host", uri->server);

 
     if (uri->port) {
         port = g_strdup_printf("%d", uri->port);
 
     if (uri->port) {
         port = g_strdup_printf("%d", uri->port);

-        qdict_put(options, VXHS_OPT_SERVER".port", qstring_from_str(port));
+        qdict_put_str(options, VXHS_OPT_SERVER ".port", port);

         g_free(port);
     }
 
         g_free(port);
     }
 

-    qdict_put(options, "vdisk-id", qstring_from_str(uri->path));
+    qdict_put_str(options, "vdisk-id", uri->path);

 
     trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);
     uri_free(uri);
 
     trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);
     uri_free(uri);


@@ -216,6 +217,12 @@ static void vxhs_parse_filename(const char *filename, QDict *options,
     }
 }
 
     }
 }
 

+static void vxhs_refresh_limits(BlockDriverState *bs, Error **errp)
+{
+    /* XXX Does VXHS support AIO on less than 512-byte alignment? */
+    bs->bl.request_alignment = 512;
+}
+

 static int vxhs_init_and_ref(void)
 {
     if (vxhs_ref++ == 0) {
 static int vxhs_init_and_ref(void)
 {
     if (vxhs_ref++ == 0) {


@@ -396,7 +403,7 @@ static int vxhs_open(BlockDriverState *bs, QDict *options,
 
 out:
     g_free(of_vsa_addr);
 
 out:
     g_free(of_vsa_addr);

-    QDECREF(backing_options);
+    qobject_unref(backing_options);

     qemu_opts_del(tcp_opts);
     qemu_opts_del(opts);
     g_free(cacert);
     qemu_opts_del(tcp_opts);
     qemu_opts_del(opts);
     g_free(cacert);


@@ -424,21 +431,17 @@ static const AIOCBInfo vxhs_aiocb_info = {
  * and is passed to QNIO. When QNIO completes the work,
  * it will be passed back through the callback.
  */
  * and is passed to QNIO. When QNIO completes the work,
  * it will be passed back through the callback.
  */

-static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num,
-                               QEMUIOVector *qiov, int nb_sectors,
+static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, uint64_t offset,
+                               QEMUIOVector *qiov, uint64_t size,

                                BlockCompletionFunc *cb, void *opaque,
                                VDISKAIOCmd iodir)
 {
     VXHSAIOCB *acb = NULL;
     BDRVVXHSState *s = bs->opaque;
                                BlockCompletionFunc *cb, void *opaque,
                                VDISKAIOCmd iodir)
 {
     VXHSAIOCB *acb = NULL;
     BDRVVXHSState *s = bs->opaque;

-    size_t size;
-    uint64_t offset;

     int iio_flags = 0;
     int ret = 0;
     void *dev_handle = s->vdisk_hostinfo.dev_handle;
 
     int iio_flags = 0;
     int ret = 0;
     void *dev_handle = s->vdisk_hostinfo.dev_handle;
 

-    offset = sector_num * BDRV_SECTOR_SIZE;
-    size = nb_sectors * BDRV_SECTOR_SIZE;

     acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);
 
     /*
     acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);
 
     /*


@@ -451,11 +454,11 @@ static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num,
     switch (iodir) {
     case VDISK_AIO_WRITE:
             ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,
     switch (iodir) {
     case VDISK_AIO_WRITE:
             ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,

-                             offset, (uint64_t)size, iio_flags);
+                             offset, size, iio_flags);

             break;
     case VDISK_AIO_READ:
             ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,
             break;
     case VDISK_AIO_READ:
             ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,

-                            offset, (uint64_t)size, iio_flags);
+                            offset, size, iio_flags);

             break;
     default:
             trace_vxhs_aio_rw_invalid(iodir);
             break;
     default:
             trace_vxhs_aio_rw_invalid(iodir);


@@ -474,22 +477,20 @@ errout:
     return NULL;
 }
 
     return NULL;
 }
 

-static BlockAIOCB *vxhs_aio_readv(BlockDriverState *bs,
-                                   int64_t sector_num, QEMUIOVector *qiov,
-                                   int nb_sectors,
+static BlockAIOCB *vxhs_aio_preadv(BlockDriverState *bs,
+                                   uint64_t offset, uint64_t bytes,
+                                   QEMUIOVector *qiov, int flags,

                                    BlockCompletionFunc *cb, void *opaque)
 {
                                    BlockCompletionFunc *cb, void *opaque)
 {

-    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
-                       opaque, VDISK_AIO_READ);
+    return vxhs_aio_rw(bs, offset, qiov, bytes, cb, opaque, VDISK_AIO_READ);

 }
 
 }
 

-static BlockAIOCB *vxhs_aio_writev(BlockDriverState *bs,
-                                   int64_t sector_num, QEMUIOVector *qiov,
-                                   int nb_sectors,
-                                   BlockCompletionFunc *cb, void *opaque)
+static BlockAIOCB *vxhs_aio_pwritev(BlockDriverState *bs,
+                                    uint64_t offset, uint64_t bytes,
+                                    QEMUIOVector *qiov, int flags,
+                                    BlockCompletionFunc *cb, void *opaque)

 {
 {

-    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors,
-                       cb, opaque, VDISK_AIO_WRITE);
+    return vxhs_aio_rw(bs, offset, qiov, bytes, cb, opaque, VDISK_AIO_WRITE);

 }
 
 static void vxhs_close(BlockDriverState *bs)
 }
 
 static void vxhs_close(BlockDriverState *bs)


@@ -555,16 +556,28 @@ static int64_t vxhs_getlength(BlockDriverState *bs)
     return vdisk_size;
 }
 
     return vdisk_size;
 }
 

+static const char *const vxhs_strong_runtime_opts[] = {
+    VXHS_OPT_VDISK_ID,
+    "tls-creds",
+    VXHS_OPT_HOST,
+    VXHS_OPT_PORT,
+    VXHS_OPT_SERVER".",
+
+    NULL
+};
+

 static BlockDriver bdrv_vxhs = {
     .format_name                  = "vxhs",
     .protocol_name                = "vxhs",
     .instance_size                = sizeof(BDRVVXHSState),
     .bdrv_file_open               = vxhs_open,
     .bdrv_parse_filename          = vxhs_parse_filename,
 static BlockDriver bdrv_vxhs = {
     .format_name                  = "vxhs",
     .protocol_name                = "vxhs",
     .instance_size                = sizeof(BDRVVXHSState),
     .bdrv_file_open               = vxhs_open,
     .bdrv_parse_filename          = vxhs_parse_filename,

+    .bdrv_refresh_limits          = vxhs_refresh_limits,

     .bdrv_close                   = vxhs_close,
     .bdrv_getlength               = vxhs_getlength,
     .bdrv_close                   = vxhs_close,
     .bdrv_getlength               = vxhs_getlength,

-    .bdrv_aio_readv               = vxhs_aio_readv,
-    .bdrv_aio_writev              = vxhs_aio_writev,
+    .bdrv_aio_preadv              = vxhs_aio_preadv,
+    .bdrv_aio_pwritev             = vxhs_aio_pwritev,
+    .strong_runtime_opts          = vxhs_strong_runtime_opts,

 };
 
 static void bdrv_vxhs_init(void)
 };
 
 static void bdrv_vxhs_init(void)