engines/glusterfs.c

   1 /*
   2  * glusterfs engine
   3  *
   4  * IO engine using Glusterfs's gfapi interface
   5  *
   6  */
   7
   8 #include <glusterfs/api/glfs.h>
   9
  10 #include "../fio.h"
  11
  12 struct gf_options {
  13     struct thread_data *td;
  14     char *gf_vol;
  15     char *gf_brick;
  16 };
  17
  18 struct gf_data {
  19     glfs_t *fs;
  20     glfs_fd_t *fd;
  21 };
  22 static struct fio_option options[] = {
  23     {
  24         .name     = "volume",
  25         .lname    = "Glusterfs volume",
  26         .type     = FIO_OPT_STR_STORE,
  27         .help     = "Name of the Glusterfs volume",
  28         .off1     = offsetof(struct gf_options, gf_vol),
  29         .category = FIO_OPT_C_ENGINE,
  30         .group    = FIO_OPT_G_GFAPI,
  31     },
  32     {
  33         .name     = "brick",
  34         .lname    = "Glusterfs brick name",
  35         .type     = FIO_OPT_STR_STORE,
  36         .help     = "Name of the Glusterfs brick to connect",
  37         .off1     = offsetof(struct gf_options, gf_brick),
  38         .category = FIO_OPT_C_ENGINE,
  39         .group    = FIO_OPT_G_GFAPI,
  40     },
  41     {
  42         .name = NULL,
  43     },
  44 };
  45
  46 static int fio_gf_setup(struct thread_data *td)
  47 {
  48         int r = 0;
  49         struct gf_data *g = NULL;
  50         struct gf_options *opt = td->eo;
  51
  52         if (td->io_ops->data)
  53             return 0;
  54
  55         g = malloc(sizeof(struct gf_data));
  56         if (!g){
  57             log_err("malloc failed.\n");
  58             return -ENOMEM;
  59         }
  60         g->fs = NULL; g->fd = NULL;
  61
  62         g->fs = glfs_new (opt->gf_vol);
  63         if (!g->fs){
  64             log_err("glfs_new failed.\n");
  65             goto cleanup;
  66         }
  67
  68         /* default to tcp */
  69         r = glfs_set_volfile_server(g->fs, "tcp", opt->gf_brick, 24007);
  70         if (r){
  71             log_err("glfs_set_volfile_server failed.\n");
  72             goto cleanup;
  73         }
  74         r = glfs_init(g->fs);
  75         if (r){
  76             log_err("glfs_init failed.\n");
  77             goto cleanup;
  78         }
  79         glfs_set_logging (g->fs, "/dev/stderr", 7);
  80
  81         td->io_ops->data = g;
  82 cleanup:
  83         if (g){
  84             if (g->fs){
  85                 glfs_fini(g->fs);
  86             }
  87             free(g);
  88         }
  89         return r;
  90 }
  91
  92 static void fio_gf_cleanup(struct thread_data *td)
  93 {
  94         struct gf_data *g = td->io_ops->data;
  95
  96         if (g){
  97             if (g->fs){
  98                 glfs_fini(g->fs);
  99             }
 100             free(g);
 101         }
 102 }
 103
 104 static int fio_gf_get_file_size(struct thread_data *td, struct fio_file *f)
 105 {
 106     struct stat buf;
 107     int ret;
 108     struct gf_data *g = td->io_ops->data;
 109
 110     dprint(FD_FILE, "get file size %s\n", f->file_name);
 111
 112     if (!g || !g->fs)
 113     {
 114         return 0;
 115     }
 116
 117     if (fio_file_size_known(f))
 118         return 0;
 119
 120     ret = glfs_lstat (g->fs, f->file_name, &buf);
 121     if (ret < 0)
 122         return ret;
 123
 124     f->real_file_size = buf.st_size;
 125     fio_file_set_size_known(f);
 126
 127     return 0;
 128
 129 }
 130
 131 static int fio_gf_open_file(struct thread_data *td, struct fio_file *f)
 132 {
 133     struct gf_data *g = td->io_ops->data;
 134     int flags = 0;
 135
 136     dprint(FD_FILE, "fd open %s\n", f->file_name);
 137
 138     if (td_write(td)) {
 139         if (!read_only)
 140             flags = O_RDWR;
 141     } else if (td_read(td)) {
 142         if (!read_only)
 143             flags = O_RDWR;
 144         else
 145             flags = O_RDONLY;
 146     }
 147     if (td->o.create_on_open)
 148         flags |= O_CREAT;
 149
 150     g->fd = glfs_open(g->fs, f->file_name, flags);
 151     f->fd = -1;
 152     return 0;
 153 }
 154
 155 static int fio_gf_close_file(struct thread_data *td, struct fio_file *f)
 156 {
 157         int ret = 0;
 158         struct gf_data *g = td->io_ops->data;
 159
 160         dprint(FD_FILE, "fd close %s\n", f->file_name);
 161
 162         if (!g->fd && glfs_close(g->fd) < 0)
 163                 ret = errno;
 164
 165         g->fd = NULL;
 166         f->engine_data = 0;
 167
 168         return ret;
 169 }
 170
 171 #define LAST_POS(f)     ((f)->engine_data)
 172 static int fio_gf_prep(struct thread_data *td, struct io_u *io_u)
 173 {
 174         struct fio_file *f = io_u->file;
 175         struct gf_data *g = td->io_ops->data;
 176
 177         if (!ddir_rw(io_u->ddir))
 178                 return 0;
 179
 180         if (LAST_POS(f) != -1ULL && LAST_POS(f) == io_u->offset)
 181                 return 0;
 182
 183         if (glfs_lseek(g->fd, io_u->offset, SEEK_SET) < 0) {
 184                 td_verror(td, errno, "lseek");
 185                 return 1;
 186         }
 187
 188         return 0;
 189 }
 190
 191 static int fio_gf_queue(struct thread_data *td, struct io_u *io_u)
 192 {
 193     struct gf_data *g = td->io_ops->data;
 194     int ret = 0;
 195
 196     fio_ro_check(td, io_u);
 197
 198     if (io_u->ddir == DDIR_READ)
 199         ret = glfs_read(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0);
 200     else if (io_u->ddir == DDIR_WRITE)
 201         ret = glfs_write(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0);
 202     else {
 203         log_err("unsupported operation.\n");
 204         return -EINVAL;
 205     }
 206     if (io_u->file && ret >= 0 && ddir_rw(io_u->ddir))
 207         LAST_POS(io_u->file) = io_u->offset + ret;
 208
 209     if (ret != (int) io_u->xfer_buflen) {
 210         if (ret >= 0) {
 211             io_u->resid = io_u->xfer_buflen - ret;
 212             io_u->error = 0;
 213             return FIO_Q_COMPLETED;
 214         } else
 215             io_u->error = errno;
 216     }
 217
 218     if (io_u->error)
 219         td_verror(td, io_u->error, "xfer");
 220
 221     return FIO_Q_COMPLETED;
 222
 223 }
 224
 225 static struct ioengine_ops ioengine = {
 226         .name               = "gfapi",
 227         .version            = FIO_IOOPS_VERSION,
 228         .setup              = fio_gf_setup,
 229         .cleanup            = fio_gf_cleanup,
 230         .prep               = fio_gf_prep,
 231         .queue              = fio_gf_queue,
 232         .open_file          = fio_gf_open_file,
 233         .close_file         = fio_gf_close_file,
 234         .get_file_size      = fio_gf_get_file_size,
 235         .options            = options,
 236         .option_struct_size = sizeof(struct gf_options),
 237         .flags              = FIO_SYNCIO,
 238 };
 239
 240 static void fio_init fio_gf_register(void)
 241 {
 242     register_ioengine(&ioengine);
 243 }
 244
 245 static void fio_exit fio_gf_unregister(void)
 246 {
 247     unregister_ioengine(&ioengine);
 248 }