Merge branch 'master' of ssh://git.kernel.dk/data/git/fio
authorJens Axboe <axboe@fb.com>
Thu, 30 Oct 2014 16:13:33 +0000 (10:13 -0600)
committerJens Axboe <axboe@fb.com>
Thu, 30 Oct 2014 16:13:33 +0000 (10:13 -0600)
configure
engines/cpu.c
engines/e4defrag.c
engines/gfapi.h
engines/glusterfs_async.c
engines/libaio.c
engines/rbd.c

index d41a1c3ae5b61570b2b614d5c1ea72e948265913..eefe28e8428c66ac7b8cb77711b18c4e6c314269 100755 (executable)
--- a/configure
+++ b/configure
@@ -1202,6 +1202,26 @@ if test "$disable_rbd" != "yes"  && compile_prog "" "-lrbd -lrados" "rbd"; then
 fi
 echo "Rados Block Device engine     $rbd"
 
+##########################################
+# check for rbd_invaidate_cache()
+rbd_inval="no"
+if test "$rbd" = "yes"; then
+cat > $TMPC << EOF
+#include <rbd/librbd.h>
+
+int main(int argc, char **argv)
+{
+  rbd_image_t image;
+
+  return rbd_invalidate_cache(image);
+}
+EOF
+if compile_prog "" "-lrbd -lrados" "rbd"; then
+  rbd_inval="yes"
+fi
+echo "rbd_invalidate_cache          $rbd_inval"
+fi
+
 ##########################################
 # Check whether we have setvbuf
 setvbuf="no"
@@ -1241,6 +1261,7 @@ fi
 
 ##########################################
 # check for gfapi fadvise support
+if test "$gfapi" = "yes" ; then
 gf_fadvise="no"
 cat > $TMPC << EOF
 #include <glusterfs/api/glfs.h>
@@ -1253,11 +1274,29 @@ int main(int argc, char **argv)
   return 0;
 }
 EOF
-
 if compile_prog "" "-lgfapi -lglusterfs" "gfapi"; then
   gf_fadvise="yes"
 fi
 echo "Gluster API use fadvise       $gf_fadvise"
+fi
+
+##########################################
+# check for gfapi trim support
+gf_trim="no"
+if test "$gfapi" = "yes" ; then
+cat > $TMPC << EOF
+#include <glusterfs/api/glfs.h>
+
+int main(int argc, char **argv)
+{
+  return glfs_discard_async(NULL, 0, 0);
+}
+EOF
+if compile_prog "" "-lgfapi -lglusterfs" "gf trim"; then
+  gf_trim="yes"
+fi
+echo "Gluster API trim support      $gf_trim"
+fi
 
 ##########################################
 # Check if we support stckf on s390
@@ -1490,6 +1529,9 @@ fi
 if test "$rbd" = "yes" ; then
   output_sym "CONFIG_RBD"
 fi
+if test "$rbd_inval" = "yes" ; then
+  output_sym "CONFIG_RBD_INVAL"
+fi
 if test "$setvbuf" = "yes" ; then
   output_sym "CONFIG_SETVBUF"
 fi
@@ -1503,6 +1545,9 @@ fi
 if test "$gf_fadvise" = "yes" ; then
   output_sym "CONFIG_GF_FADVISE"
 fi
+if test "$gf_trim" = "yes" ; then
+  output_sym "CONFIG_GF_TRIM"
+fi
 if test "$libhdfs" = "yes" ; then
   output_sym "CONFIG_LIBHDFS"
 fi
index 85598ef77fb9acd8d4868d6e15de1d9f64bee83f..7e4d7374accd24399a6d780639f5c94f05c5c9a3 100644 (file)
@@ -8,7 +8,7 @@
 #include "../fio.h"
 
 struct cpu_options {
-       struct thread_data *td;
+       void *pad;
        unsigned int cpuload;
        unsigned int cpucycle;
        unsigned int exit_io_done;
index 3599ab8a49ce708087c4ac88b18b74bd728bec95..6854070932a4d065a3989840b9b758cd4a0a494f 100644 (file)
@@ -36,7 +36,7 @@ struct e4defrag_data {
 };
 
 struct e4defrag_options {
-       struct thread_data *td;
+       void *pad;
        unsigned int inplace;
        char * donor_name;
 };
index 0da471c7499b5e4811f7c289b0930e14959ba6ac..1028431415e649af01e2457754a4944355f57a81 100644 (file)
@@ -2,7 +2,7 @@
 #include "../fio.h"
 
 struct gf_options {
-       struct thread_data *td;
+       void *pad;
        char *gf_vol;
        char *gf_brick;
 };
index cf6ea709a733f6b1eef4d52719a302d55aee00cd..95ca84ef2def417aefb31ce70ce39d44503271af 100644 (file)
@@ -10,11 +10,11 @@ struct fio_gf_iou {
        struct io_u *io_u;
        int io_complete;
 };
-static ulong cb_count = 0, issued = 0;
 
 static struct io_u *fio_gf_event(struct thread_data *td, int event)
 {
        struct gf_data *gf_data = td->io_ops->data;
+
        dprint(FD_IO, "%s\n", __FUNCTION__);
        return gf_data->aio_events[event];
 }
@@ -25,18 +25,18 @@ static int fio_gf_getevents(struct thread_data *td, unsigned int min,
        struct gf_data *g = td->io_ops->data;
        unsigned int events = 0;
        struct io_u *io_u;
-       int i = 0;
-       struct fio_gf_iou *io = NULL;
+       int i;
 
        dprint(FD_IO, "%s\n", __FUNCTION__);
        do {
                io_u_qiter(&td->io_u_all, io_u, i) {
+                       struct fio_gf_iou *io;
+
                        if (!(io_u->flags & IO_U_F_FLIGHT))
                                continue;
 
-                       io = (struct fio_gf_iou *)io_u->engine_data;
-
-                       if (io && io->io_complete) {
+                       io = io_u->engine_data;
+                       if (io->io_complete) {
                                io->io_complete = 0;
                                g->aio_events[events] = io_u;
                                events++;
@@ -61,22 +61,20 @@ static void fio_gf_io_u_free(struct thread_data *td, struct io_u *io_u)
        struct fio_gf_iou *io = io_u->engine_data;
 
        if (io) {
-               if (io->io_complete) {
+               if (io->io_complete)
                        log_err("incomplete IO found.\n");
-               }
                io_u->engine_data = NULL;
                free(io);
        }
-       log_err("issued %lu finished %lu\n", issued, cb_count);
 }
 
 static int fio_gf_io_u_init(struct thread_data *td, struct io_u *io_u)
 {
-       struct fio_gf_iou *io = NULL;
-
        dprint(FD_FILE, "%s\n", __FUNCTION__);
 
        if (!io_u->engine_data) {
+               struct fio_gf_iou *io;
+
                io = malloc(sizeof(struct fio_gf_iou));
                if (!io) {
                        td_verror(td, errno, "malloc");
@@ -91,48 +89,44 @@ static int fio_gf_io_u_init(struct thread_data *td, struct io_u *io_u)
 
 static void gf_async_cb(glfs_fd_t * fd, ssize_t ret, void *data)
 {
-       struct io_u *io_u = (struct io_u *)data;
-       struct fio_gf_iou *iou = (struct fio_gf_iou *)io_u->engine_data;
+       struct io_u *io_u = data;
+       struct fio_gf_iou *iou = io_u->engine_data;
 
        dprint(FD_IO, "%s ret %lu\n", __FUNCTION__, ret);
        iou->io_complete = 1;
-       cb_count++;
 }
 
 static int fio_gf_async_queue(struct thread_data fio_unused * td,
                              struct io_u *io_u)
 {
        struct gf_data *g = td->io_ops->data;
-       int r = 0;
+       int r;
 
-       dprint(FD_IO, "%s op %s\n", __FUNCTION__,
-              io_u->ddir == DDIR_READ ? "read" : io_u->ddir ==
-              DDIR_WRITE ? "write" : io_u->ddir ==
-              DDIR_SYNC ? "sync" : "unknown");
+       dprint(FD_IO, "%s op %s\n", __FUNCTION__, io_ddir_name(io_u->ddir));
 
        fio_ro_check(td, io_u);
 
        if (io_u->ddir == DDIR_READ)
                r = glfs_pread_async(g->fd, io_u->xfer_buf, io_u->xfer_buflen,
-                                    io_u->offset, 0, gf_async_cb,
-                                    (void *)io_u);
+                                    io_u->offset, 0, gf_async_cb, io_u);
        else if (io_u->ddir == DDIR_WRITE)
                r = glfs_pwrite_async(g->fd, io_u->xfer_buf, io_u->xfer_buflen,
-                                     io_u->offset, 0, gf_async_cb,
-                                     (void *)io_u);
-       else if (io_u->ddir == DDIR_SYNC) {
-               r = glfs_fsync_async(g->fd, gf_async_cb, (void *)io_u);
-       } else {
-               log_err("unsupported operation.\n");
-               io_u->error = -EINVAL;
-               goto failed;
-       }
+                                     io_u->offset, 0, gf_async_cb, io_u);
+#if defined(CONFIG_GF_TRIM)
+       else if (io_u->ddir == DDIR_TRIM)
+               r = glfs_discard_async(g->fd, io_u->offset, io_u->xfer_buflen,
+                                      gf_async_cb, io_u);
+#endif
+       else if (io_u->ddir == DDIR_SYNC)
+               r = glfs_fsync_async(g->fd, gf_async_cb, io_u);
+       else
+               r = -EINVAL;
+
        if (r) {
-               log_err("glfs failed.\n");
+               log_err("glfs queue failed.\n");
                io_u->error = r;
                goto failed;
        }
-       issued++;
        return FIO_Q_QUEUED;
 
 failed:
@@ -143,39 +137,26 @@ failed:
 
 int fio_gf_async_setup(struct thread_data *td)
 {
-       int r = 0;
-       struct gf_data *g = NULL;
+       struct gf_data *g;
+       int r;
 
 #if defined(NOT_YET)
        log_err("the async interface is still very experimental...\n");
 #endif
        r = fio_gf_setup(td);
-       if (r) {
+       if (r)
                return r;
-       }
+
        td->o.use_thread = 1;
        g = td->io_ops->data;
-       g->aio_events = malloc(td->o.iodepth * sizeof(struct io_u *));
+       g->aio_events = calloc(td->o.iodepth, sizeof(struct io_u *));
        if (!g->aio_events) {
                r = -ENOMEM;
                fio_gf_cleanup(td);
                return r;
        }
 
-       memset(g->aio_events, 0, td->o.iodepth * sizeof(struct io_u *));
-
        return r;
-
-}
-
-static int fio_gf_async_prep(struct thread_data *td, struct io_u *io_u)
-{
-       dprint(FD_FILE, "%s\n", __FUNCTION__);
-
-       if (!ddir_rw(io_u->ddir))
-               return 0;
-
-       return 0;
 }
 
 static struct ioengine_ops ioengine = {
@@ -183,7 +164,6 @@ static struct ioengine_ops ioengine = {
        .version = FIO_IOOPS_VERSION,
        .init = fio_gf_async_setup,
        .cleanup = fio_gf_cleanup,
-       .prep = fio_gf_async_prep,
        .queue = fio_gf_async_queue,
        .open_file = fio_gf_open_file,
        .close_file = fio_gf_close_file,
index f7e2f8967c8900a1d5c6839dda1d746df5986b60..d4f48303becb8af99a63bcc0e1667a030bdd0a66 100644 (file)
@@ -37,7 +37,7 @@ struct libaio_data {
 };
 
 struct libaio_options {
-       struct thread_data *td;
+       void *pad;
        unsigned int userspace_reap;
 };
 
index 5160c32aedb09aa2b1e780e9a04625e1ae653a55..3688577f7404b242df88116946166a30f08dab60 100644 (file)
@@ -12,8 +12,8 @@
 struct fio_rbd_iou {
        struct io_u *io_u;
        rbd_completion_t completion;
-       int io_complete;
        int io_seen;
+       int io_complete;
 };
 
 struct rbd_data {
@@ -21,13 +21,15 @@ struct rbd_data {
        rados_ioctx_t io_ctx;
        rbd_image_t image;
        struct io_u **aio_events;
+       struct io_u **sort_events;
 };
 
 struct rbd_options {
-       struct thread_data *td;
+       void *pad;
        char *rbd_name;
        char *pool_name;
        char *client_name;
+       int busy_poll;
 };
 
 static struct fio_option options[] = {
@@ -41,22 +43,32 @@ static struct fio_option options[] = {
                .group          = FIO_OPT_G_RBD,
        },
        {
-               .name     = "pool",
-               .lname    = "rbd engine pool",
-               .type     = FIO_OPT_STR_STORE,
-               .help     = "Name of the pool hosting the RBD for the RBD engine",
-               .off1     = offsetof(struct rbd_options, pool_name),
-               .category = FIO_OPT_C_ENGINE,
-               .group    = FIO_OPT_G_RBD,
+               .name           = "pool",
+               .lname          = "rbd engine pool",
+               .type           = FIO_OPT_STR_STORE,
+               .help           = "Name of the pool hosting the RBD for the RBD engine",
+               .off1           = offsetof(struct rbd_options, pool_name),
+               .category       = FIO_OPT_C_ENGINE,
+               .group          = FIO_OPT_G_RBD,
        },
        {
-               .name     = "clientname",
-               .lname    = "rbd engine clientname",
-               .type     = FIO_OPT_STR_STORE,
-               .help     = "Name of the ceph client to access the RBD for the RBD engine",
-               .off1     = offsetof(struct rbd_options, client_name),
-               .category = FIO_OPT_C_ENGINE,
-               .group    = FIO_OPT_G_RBD,
+               .name           = "clientname",
+               .lname          = "rbd engine clientname",
+               .type           = FIO_OPT_STR_STORE,
+               .help           = "Name of the ceph client to access the RBD for the RBD engine",
+               .off1           = offsetof(struct rbd_options, client_name),
+               .category       = FIO_OPT_C_ENGINE,
+               .group          = FIO_OPT_G_RBD,
+       },
+       {
+               .name           = "busy_poll",
+               .lname          = "Busy poll",
+               .type           = FIO_OPT_BOOL,
+               .help           = "Busy poll for completions instead of sleeping",
+               .off1           = offsetof(struct rbd_options, busy_poll),
+               .def            = "0",
+               .category       = FIO_OPT_C_ENGINE,
+               .group          = FIO_OPT_G_RBD,
        },
        {
                .name = NULL,
@@ -66,67 +78,64 @@ static struct fio_option options[] = {
 static int _fio_setup_rbd_data(struct thread_data *td,
                               struct rbd_data **rbd_data_ptr)
 {
-       struct rbd_data *rbd_data;
+       struct rbd_data *rbd;
 
        if (td->io_ops->data)
                return 0;
 
-       rbd_data = malloc(sizeof(struct rbd_data));
-       if (!rbd_data)
+       rbd = calloc(1, sizeof(struct rbd_data));
+       if (!rbd)
                goto failed;
 
-       memset(rbd_data, 0, sizeof(struct rbd_data));
-
-       rbd_data->aio_events = malloc(td->o.iodepth * sizeof(struct io_u *));
-       if (!rbd_data->aio_events)
+       rbd->aio_events = calloc(td->o.iodepth, sizeof(struct io_u *));
+       if (!rbd->aio_events)
                goto failed;
 
-       memset(rbd_data->aio_events, 0, td->o.iodepth * sizeof(struct io_u *));
-
-       *rbd_data_ptr = rbd_data;
+       rbd->sort_events = calloc(td->o.iodepth, sizeof(struct io_u *));
+       if (!rbd->sort_events)
+               goto failed;
 
+       *rbd_data_ptr = rbd;
        return 0;
 
 failed:
-       if (rbd_data)
-               free(rbd_data);
+       if (rbd)
+               free(rbd);
        return 1;
 
 }
 
 static int _fio_rbd_connect(struct thread_data *td)
 {
-       struct rbd_data *rbd_data = td->io_ops->data;
+       struct rbd_data *rbd = td->io_ops->data;
        struct rbd_options *o = td->eo;
        int r;
 
-       r = rados_create(&(rbd_data->cluster), o->client_name);
+       r = rados_create(&rbd->cluster, o->client_name);
        if (r < 0) {
                log_err("rados_create failed.\n");
                goto failed_early;
        }
 
-       r = rados_conf_read_file(rbd_data->cluster, NULL);
+       r = rados_conf_read_file(rbd->cluster, NULL);
        if (r < 0) {
                log_err("rados_conf_read_file failed.\n");
                goto failed_early;
        }
 
-       r = rados_connect(rbd_data->cluster);
+       r = rados_connect(rbd->cluster);
        if (r < 0) {
                log_err("rados_connect failed.\n");
                goto failed_shutdown;
        }
 
-       r = rados_ioctx_create(rbd_data->cluster, o->pool_name,
-                              &(rbd_data->io_ctx));
+       r = rados_ioctx_create(rbd->cluster, o->pool_name, &rbd->io_ctx);
        if (r < 0) {
                log_err("rados_ioctx_create failed.\n");
                goto failed_shutdown;
        }
 
-       r = rbd_open(rbd_data->io_ctx, o->rbd_name, &(rbd_data->image),
-                    NULL /*snap */ );
+       r = rbd_open(rbd->io_ctx, o->rbd_name, &rbd->image, NULL /*snap */ );
        if (r < 0) {
                log_err("rbd_open failed.\n");
                goto failed_open;
@@ -134,50 +143,50 @@ static int _fio_rbd_connect(struct thread_data *td)
        return 0;
 
 failed_open:
-       rados_ioctx_destroy(rbd_data->io_ctx);
-       rbd_data->io_ctx = NULL;
+       rados_ioctx_destroy(rbd->io_ctx);
+       rbd->io_ctx = NULL;
 failed_shutdown:
-       rados_shutdown(rbd_data->cluster);
-       rbd_data->cluster = NULL;
+       rados_shutdown(rbd->cluster);
+       rbd->cluster = NULL;
 failed_early:
        return 1;
 }
 
-static void _fio_rbd_disconnect(struct rbd_data *rbd_data)
+static void _fio_rbd_disconnect(struct rbd_data *rbd)
 {
-       if (!rbd_data)
+       if (!rbd)
                return;
 
        /* shutdown everything */
-       if (rbd_data->image) {
-               rbd_close(rbd_data->image);
-               rbd_data->image = NULL;
+       if (rbd->image) {
+               rbd_close(rbd->image);
+               rbd->image = NULL;
        }
 
-       if (rbd_data->io_ctx) {
-               rados_ioctx_destroy(rbd_data->io_ctx);
-               rbd_data->io_ctx = NULL;
+       if (rbd->io_ctx) {
+               rados_ioctx_destroy(rbd->io_ctx);
+               rbd->io_ctx = NULL;
        }
 
-       if (rbd_data->cluster) {
-               rados_shutdown(rbd_data->cluster);
-               rbd_data->cluster = NULL;
+       if (rbd->cluster) {
+               rados_shutdown(rbd->cluster);
+               rbd->cluster = NULL;
        }
 }
 
 static void _fio_rbd_finish_aiocb(rbd_completion_t comp, void *data)
 {
-       struct io_u *io_u = data;
-       struct fio_rbd_iou *fri = io_u->engine_data;
+       struct fio_rbd_iou *fri = data;
+       struct io_u *io_u = fri->io_u;
        ssize_t ret;
 
-       fri->io_complete = 1;
-
        /*
         * Looks like return value is 0 for success, or < 0 for
         * a specific error. So we have to assume that it can't do
         * partial completions.
         */
+       fri->io_complete = 1;
+       
        ret = rbd_aio_get_return_value(fri->completion);
        if (ret < 0) {
                io_u->error = ret;
@@ -188,21 +197,19 @@ static void _fio_rbd_finish_aiocb(rbd_completion_t comp, void *data)
 
 static struct io_u *fio_rbd_event(struct thread_data *td, int event)
 {
-       struct rbd_data *rbd_data = td->io_ops->data;
+       struct rbd_data *rbd = td->io_ops->data;
 
-       return rbd_data->aio_events[event];
+       return rbd->aio_events[event];
 }
 
-static inline int fri_check_complete(struct rbd_data *rbd_data,
-                                    struct io_u *io_u,
+static inline int fri_check_complete(struct rbd_data *rbd, struct io_u *io_u,
                                     unsigned int *events)
 {
        struct fio_rbd_iou *fri = io_u->engine_data;
 
        if (fri->io_complete) {
-               fri->io_complete = 0;
                fri->io_seen = 1;
-               rbd_data->aio_events[*events] = io_u;
+               rbd->aio_events[*events] = io_u;
                (*events)++;
 
                rbd_aio_release(fri->completion);
@@ -212,32 +219,88 @@ static inline int fri_check_complete(struct rbd_data *rbd_data,
        return 0;
 }
 
+static inline int rbd_io_u_seen(struct io_u *io_u)
+{
+       struct fio_rbd_iou *fri = io_u->engine_data;
+
+       return fri->io_seen;
+}
+
+static void rbd_io_u_wait_complete(struct io_u *io_u)
+{
+       struct fio_rbd_iou *fri = io_u->engine_data;
+
+       rbd_aio_wait_for_complete(fri->completion);
+}
+
+static int rbd_io_u_cmp(const void *p1, const void *p2)
+{
+       const struct io_u **a = (const struct io_u **) p1;
+       const struct io_u **b = (const struct io_u **) p2;
+       uint64_t at, bt;
+
+       at = utime_since_now(&(*a)->start_time);
+       bt = utime_since_now(&(*b)->start_time);
+
+       if (at < bt)
+               return -1;
+       else if (at == bt)
+               return 0;
+       else
+               return 1;
+}
+
 static int rbd_iter_events(struct thread_data *td, unsigned int *events,
                           unsigned int min_evts, int wait)
 {
-       struct rbd_data *rbd_data = td->io_ops->data;
+       struct rbd_data *rbd = td->io_ops->data;
        unsigned int this_events = 0;
        struct io_u *io_u;
-       int i;
+       int i, sidx;
 
+       sidx = 0;
        io_u_qiter(&td->io_u_all, io_u, i) {
-               struct fio_rbd_iou *fri = io_u->engine_data;
-
                if (!(io_u->flags & IO_U_F_FLIGHT))
                        continue;
-               if (fri->io_seen)
+               if (rbd_io_u_seen(io_u))
                        continue;
 
-               if (fri_check_complete(rbd_data, io_u, events))
+               if (fri_check_complete(rbd, io_u, events))
                        this_events++;
-               else if (wait) {
-                       rbd_aio_wait_for_complete(fri->completion);
+               else if (wait)
+                       rbd->sort_events[sidx++] = io_u;
+       }
 
-                       if (fri_check_complete(rbd_data, io_u, events))
-                               this_events++;
+       if (!wait || !sidx)
+               return this_events;
+
+       /*
+        * Sort events, oldest issue first, then wait on as many as we
+        * need in order of age. If we have enough events, stop waiting,
+        * and just check if any of the older ones are done.
+        */
+       if (sidx > 1)
+               qsort(rbd->sort_events, sidx, sizeof(struct io_u *), rbd_io_u_cmp);
+
+       for (i = 0; i < sidx; i++) {
+               io_u = rbd->sort_events[i];
+
+               if (fri_check_complete(rbd, io_u, events)) {
+                       this_events++;
+                       continue;
                }
+
+               /*
+                * Stop waiting when we have enough, but continue checking
+                * all pending IOs if they are complete.
+                */
                if (*events >= min_evts)
-                       break;
+                       continue;
+
+               rbd_io_u_wait_complete(io_u);
+
+               if (fri_check_complete(rbd, io_u, events))
+                       this_events++;
        }
 
        return this_events;
@@ -247,6 +310,7 @@ static int fio_rbd_getevents(struct thread_data *td, unsigned int min,
                             unsigned int max, const struct timespec *t)
 {
        unsigned int this_events, events = 0;
+       struct rbd_options *o = td->eo;
        int wait = 0;
 
        do {
@@ -257,7 +321,10 @@ static int fio_rbd_getevents(struct thread_data *td, unsigned int min,
                if (this_events)
                        continue;
 
-               wait = 1;
+               if (!o->busy_poll)
+                       wait = 1;
+               else
+                       nop;
        } while (1);
 
        return events;
@@ -265,76 +332,60 @@ static int fio_rbd_getevents(struct thread_data *td, unsigned int min,
 
 static int fio_rbd_queue(struct thread_data *td, struct io_u *io_u)
 {
-       struct rbd_data *rbd_data = td->io_ops->data;
+       struct rbd_data *rbd = td->io_ops->data;
        struct fio_rbd_iou *fri = io_u->engine_data;
        int r = -1;
 
        fio_ro_check(td, io_u);
 
-       fri->io_complete = 0;
        fri->io_seen = 0;
+       fri->io_complete = 0;
 
-       if (io_u->ddir == DDIR_WRITE) {
-               r = rbd_aio_create_completion(io_u, _fio_rbd_finish_aiocb,
+       r = rbd_aio_create_completion(fri, _fio_rbd_finish_aiocb,
                                                &fri->completion);
-               if (r < 0) {
-                       log_err
-                           ("rbd_aio_create_completion for DDIR_WRITE failed.\n");
-                       goto failed;
-               }
+       if (r < 0) {
+               log_err("rbd_aio_create_completion failed.\n");
+               goto failed;
+       }
 
-               r = rbd_aio_write(rbd_data->image, io_u->offset,
-                                 io_u->xfer_buflen, io_u->xfer_buf,
-                                 fri->completion);
+       if (io_u->ddir == DDIR_WRITE) {
+               r = rbd_aio_write(rbd->image, io_u->offset, io_u->xfer_buflen,
+                                        io_u->xfer_buf, fri->completion);
                if (r < 0) {
                        log_err("rbd_aio_write failed.\n");
-                       rbd_aio_release(fri->completion);
-                       goto failed;
+                       goto failed_comp;
                }
 
        } else if (io_u->ddir == DDIR_READ) {
-               r = rbd_aio_create_completion(io_u, _fio_rbd_finish_aiocb,
-                                               &fri->completion);
-               if (r < 0) {
-                       log_err
-                           ("rbd_aio_create_completion for DDIR_READ failed.\n");
-                       goto failed;
-               }
-
-               r = rbd_aio_read(rbd_data->image, io_u->offset,
-                                io_u->xfer_buflen, io_u->xfer_buf,
-                                fri->completion);
+               r = rbd_aio_read(rbd->image, io_u->offset, io_u->xfer_buflen,
+                                       io_u->xfer_buf, fri->completion);
 
                if (r < 0) {
                        log_err("rbd_aio_read failed.\n");
-                       rbd_aio_release(fri->completion);
-                       goto failed;
+                       goto failed_comp;
                }
-
-       } else if (io_u->ddir == DDIR_SYNC) {
-               r = rbd_aio_create_completion(io_u, _fio_rbd_finish_aiocb,
-                                               &fri->completion);
+       } else if (io_u->ddir == DDIR_TRIM) {
+               r = rbd_aio_discard(rbd->image, io_u->offset,
+                                       io_u->xfer_buflen, fri->completion);
                if (r < 0) {
-                       log_err
-                           ("rbd_aio_create_completion for DDIR_SYNC failed.\n");
-                       goto failed;
+                       log_err("rbd_aio_discard failed.\n");
+                       goto failed_comp;
                }
-
-               r = rbd_aio_flush(rbd_data->image, fri->completion);
+       } else if (io_u->ddir == DDIR_SYNC) {
+               r = rbd_aio_flush(rbd->image, fri->completion);
                if (r < 0) {
                        log_err("rbd_flush failed.\n");
-                       rbd_aio_release(fri->completion);
-                       goto failed;
+                       goto failed_comp;
                }
-
        } else {
                dprint(FD_IO, "%s: Warning: unhandled ddir: %d\n", __func__,
                       io_u->ddir);
-               return FIO_Q_COMPLETED;
+               goto failed_comp;
        }
 
        return FIO_Q_QUEUED;
-
+failed_comp:
+       rbd_aio_release(fri->completion);
 failed:
        io_u->error = r;
        td_verror(td, io_u->error, "xfer");
@@ -359,35 +410,35 @@ failed:
 
 static void fio_rbd_cleanup(struct thread_data *td)
 {
-       struct rbd_data *rbd_data = td->io_ops->data;
+       struct rbd_data *rbd = td->io_ops->data;
 
-       if (rbd_data) {
-               _fio_rbd_disconnect(rbd_data);
-               free(rbd_data->aio_events);
-               free(rbd_data);
+       if (rbd) {
+               _fio_rbd_disconnect(rbd);
+               free(rbd->aio_events);
+               free(rbd->sort_events);
+               free(rbd);
        }
-
 }
 
 static int fio_rbd_setup(struct thread_data *td)
 {
-       int r = 0;
        rbd_image_info_t info;
        struct fio_file *f;
-       struct rbd_data *rbd_data = NULL;
+       struct rbd_data *rbd = NULL;
        int major, minor, extra;
+       int r;
 
        /* log version of librbd. No cluster connection required. */
        rbd_version(&major, &minor, &extra);
        log_info("rbd engine: RBD version: %d.%d.%d\n", major, minor, extra);
 
        /* allocate engine specific structure to deal with librbd. */
-       r = _fio_setup_rbd_data(td, &rbd_data);
+       r = _fio_setup_rbd_data(td, &rbd);
        if (r) {
                log_err("fio_setup_rbd_data failed.\n");
                goto cleanup;
        }
-       td->io_ops->data = rbd_data;
+       td->io_ops->data = rbd;
 
        /* librbd does not allow us to run first in the main thread and later
         * in a fork child. It needs to be the same process context all the
@@ -406,7 +457,7 @@ static int fio_rbd_setup(struct thread_data *td)
        }
 
        /* get size of the RADOS block device */
-       r = rbd_stat(rbd_data->image, &info, sizeof(info));
+       r = rbd_stat(rbd->image, &info, sizeof(info));
        if (r < 0) {
                log_err("rbd_status failed.\n");
                goto disconnect;
@@ -428,11 +479,11 @@ static int fio_rbd_setup(struct thread_data *td)
        /* disconnect, then we were only connected to determine
         * the size of the RBD.
         */
-       _fio_rbd_disconnect(rbd_data);
+       _fio_rbd_disconnect(rbd);
        return 0;
 
 disconnect:
-       _fio_rbd_disconnect(rbd_data);
+       _fio_rbd_disconnect(rbd);
 cleanup:
        fio_rbd_cleanup(td);
        return r;
@@ -445,7 +496,13 @@ static int fio_rbd_open(struct thread_data *td, struct fio_file *f)
 
 static int fio_rbd_invalidate(struct thread_data *td, struct fio_file *f)
 {
+#if defined(CONFIG_RBD_INVAL)
+       struct rbd_data *rbd = td->io_ops->data;
+
+       return rbd_invalidate_cache(rbd->image);
+#else
        return 0;
+#endif
 }
 
 static void fio_rbd_io_u_free(struct thread_data *td, struct io_u *io_u)