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     if (fio_file_size_known(f))
 111         return 0;
 112
 113     ret = glfs_lstat (g->fs, f->file_name, &buf);
 114     if (ret < 0)
 115         return ret;
 116
 117     f->real_file_size = buf.st_size;
 118     fio_file_set_size_known(f);
 119
 120     return 0;
 121
 122 }
 123
 124 static int fio_gf_open_file(struct thread_data *td, struct fio_file *f)
 125 {
 126     struct gf_data *g = td->io_ops->data;
 127     int flags = 0;
 128
 129     dprint(FD_FILE, "fd open %s\n", f->file_name);
 130
 131     if (td_write(td)) {
 132         if (!read_only)
 133             flags = O_RDWR;
 134     } else if (td_read(td)) {
 135         if (!read_only)
 136             flags = O_RDWR;
 137         else
 138             flags = O_RDONLY;
 139     }
 140     if (td->o.create_on_open)
 141         flags |= O_CREAT;
 142
 143     g->fd = glfs_open(g->fs, f->file_name, flags);
 144     f->fd = -1;
 145     return 0;
 146 }
 147
 148 static int fio_gf_close_file(struct thread_data *td, struct fio_file *f)
 149 {
 150         int ret = 0;
 151         struct gf_data *g = td->io_ops->data;
 152
 153         dprint(FD_FILE, "fd close %s\n", f->file_name);
 154
 155         if (!g->fd && glfs_close(g->fd) < 0)
 156                 ret = errno;
 157
 158         g->fd = NULL;
 159         f->engine_data = 0;
 160
 161         return ret;
 162 }
 163
 164 #define LAST_POS(f)     ((f)->engine_data)
 165 static int fio_gf_prep(struct thread_data *td, struct io_u *io_u)
 166 {
 167         struct fio_file *f = io_u->file;
 168         struct gf_data *g = td->io_ops->data;
 169
 170         if (!ddir_rw(io_u->ddir))
 171                 return 0;
 172
 173         if (LAST_POS(f) != -1ULL && LAST_POS(f) == io_u->offset)
 174                 return 0;
 175
 176         if (glfs_lseek(g->fd, io_u->offset, SEEK_SET) < 0) {
 177                 td_verror(td, errno, "lseek");
 178                 return 1;
 179         }
 180
 181         return 0;
 182 }
 183
 184 static int fio_gf_queue(struct thread_data *td, struct io_u *io_u)
 185 {
 186     struct gf_data *g = td->io_ops->data;
 187     int ret = 0;
 188
 189     fio_ro_check(td, io_u);
 190
 191     if (io_u->ddir == DDIR_READ)
 192         ret = glfs_read(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0);
 193     else if (io_u->ddir == DDIR_WRITE)
 194         ret = glfs_write(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0);
 195     else {
 196         log_err("unsupported operation.\n");
 197         return -EINVAL;
 198     }
 199     if (io_u->file && ret >= 0 && ddir_rw(io_u->ddir))
 200         LAST_POS(io_u->file) = io_u->offset + ret;
 201
 202     if (ret != (int) io_u->xfer_buflen) {
 203         if (ret >= 0) {
 204             io_u->resid = io_u->xfer_buflen - ret;
 205             io_u->error = 0;
 206             return FIO_Q_COMPLETED;
 207         } else
 208             io_u->error = errno;
 209     }
 210
 211     if (io_u->error)
 212         td_verror(td, io_u->error, "xfer");
 213
 214     return FIO_Q_COMPLETED;
 215
 216 }
 217
 218 static struct ioengine_ops ioengine = {
 219         .name               = "gfapi",
 220         .version            = FIO_IOOPS_VERSION,
 221         .setup              = fio_gf_setup,
 222         .cleanup            = fio_gf_cleanup,
 223         .prep               = fio_gf_prep,
 224         .queue              = fio_gf_queue,
 225         .open_file          = fio_gf_open_file,
 226         .close_file         = fio_gf_close_file,
 227         .get_file_size      = fio_gf_get_file_size,
 228         .options            = options,
 229         .option_struct_size = sizeof(struct gf_options),
 230         .flags              = FIO_SYNCIO,
 231 };
 232
 233 static void fio_init fio_gf_register(void)
 234 {
 235     register_ioengine(&ioengine);
 236 }
 237
 238 static void fio_exit fio_gf_unregister(void)
 239 {
 240     unregister_ioengine(&ioengine);
 241 }