engines/glusterfs.c

   1 /*
   2  * glusterfs engine
   3  *
   4  * common Glusterfs's gfapi interface
   5  *
   6  */
   7
   8 #include "gfapi.h"
   9
  10 struct fio_option gfapi_options[] = {
  11         {
  12          .name = "volume",
  13          .lname = "Glusterfs volume",
  14          .type = FIO_OPT_STR_STORE,
  15          .help = "Name of the Glusterfs volume",
  16          .off1 = offsetof(struct gf_options, gf_vol),
  17          .category = FIO_OPT_C_ENGINE,
  18          .group = FIO_OPT_G_GFAPI,
  19          },
  20         {
  21          .name = "brick",
  22          .lname = "Glusterfs brick name",
  23          .type = FIO_OPT_STR_STORE,
  24          .help = "Name of the Glusterfs brick to connect",
  25          .off1 = offsetof(struct gf_options, gf_brick),
  26          .category = FIO_OPT_C_ENGINE,
  27          .group = FIO_OPT_G_GFAPI,
  28          },
  29         {
  30          .name = NULL,
  31          },
  32 };
  33
  34 int fio_gf_setup(struct thread_data *td)
  35 {
  36         int r = 0;
  37         struct gf_data *g = NULL;
  38         struct gf_options *opt = td->eo;
  39         struct stat sb = { 0, };
  40
  41         dprint(FD_IO, "fio setup\n");
  42
  43         if (td->io_ops->data)
  44                 return 0;
  45
  46         g = malloc(sizeof(struct gf_data));
  47         if (!g) {
  48                 log_err("malloc failed.\n");
  49                 return -ENOMEM;
  50         }
  51         g->fs = NULL;
  52         g->fd = NULL;
  53         g->aio_events = NULL;
  54
  55         g->fs = glfs_new(opt->gf_vol);
  56         if (!g->fs) {
  57                 log_err("glfs_new failed.\n");
  58                 goto cleanup;
  59         }
  60         glfs_set_logging(g->fs, "/tmp/fio_gfapi.log", 7);
  61         /* default to tcp */
  62         r = glfs_set_volfile_server(g->fs, "tcp", opt->gf_brick, 0);
  63         if (r) {
  64                 log_err("glfs_set_volfile_server failed.\n");
  65                 goto cleanup;
  66         }
  67         r = glfs_init(g->fs);
  68         if (r) {
  69                 log_err("glfs_init failed. Is glusterd running on brick?\n");
  70                 goto cleanup;
  71         }
  72         sleep(2);
  73         r = glfs_lstat(g->fs, ".", &sb);
  74         if (r) {
  75                 log_err("glfs_lstat failed.\n");
  76                 goto cleanup;
  77         }
  78         dprint(FD_FILE, "fio setup %p\n", g->fs);
  79         td->io_ops->data = g;
  80         return 0;
  81 cleanup:
  82         if (g->fs)
  83                 glfs_fini(g->fs);
  84         free(g);
  85         td->io_ops->data = NULL;
  86         return r;
  87 }
  88
  89 void fio_gf_cleanup(struct thread_data *td)
  90 {
  91         struct gf_data *g = td->io_ops->data;
  92
  93         if (g) {
  94                 if (g->aio_events)
  95                         free(g->aio_events);
  96                 if (g->fd)
  97                         glfs_close(g->fd);
  98                 if (g->fs)
  99                         glfs_fini(g->fs);
 100                 free(g);
 101                 td->io_ops->data = NULL;
 102         }
 103 }
 104
 105 int fio_gf_get_file_size(struct thread_data *td, struct fio_file *f)
 106 {
 107         struct stat buf;
 108         int ret;
 109         struct gf_data *g = td->io_ops->data;
 110
 111         dprint(FD_FILE, "get file size %s\n", f->file_name);
 112
 113         if (!g || !g->fs) {
 114                 return 0;
 115         }
 116         if (fio_file_size_known(f))
 117                 return 0;
 118
 119         ret = glfs_lstat(g->fs, f->file_name, &buf);
 120         if (ret < 0) {
 121                 log_err("glfs_lstat failed.\n");
 122                 return ret;
 123         }
 124
 125         f->real_file_size = buf.st_size;
 126         fio_file_set_size_known(f);
 127
 128         return 0;
 129
 130 }
 131
 132 int fio_gf_open_file(struct thread_data *td, struct fio_file *f)
 133 {
 134
 135         int flags = 0;
 136         int ret = 0;
 137         struct gf_data *g = td->io_ops->data;
 138         struct stat sb = { 0, };
 139
 140         if (td_write(td)) {
 141                 if (!read_only)
 142                         flags = O_RDWR;
 143         } else if (td_read(td)) {
 144                 if (!read_only)
 145                         flags = O_RDWR;
 146                 else
 147                         flags = O_RDONLY;
 148         }
 149
 150         if (td->o.odirect)
 151                 flags |= OS_O_DIRECT;
 152         if (td->o.sync_io)
 153                 flags |= O_SYNC;
 154
 155         dprint(FD_FILE, "fio file %s open mode %s td rw %s\n", f->file_name,
 156                flags & O_RDONLY ? "ro" : "rw", td_read(td) ? "read" : "write");
 157         g->fd = glfs_creat(g->fs, f->file_name, flags, 0644);
 158         if (!g->fd) {
 159                 ret = errno;
 160                 log_err("glfs_creat failed.\n");
 161                 return ret;
 162         }
 163         /* file for read doesn't exist or shorter than required, create/extend it */
 164         if (td_read(td)) {
 165                 if (glfs_lstat(g->fs, f->file_name, &sb)
 166                     || sb.st_size < f->real_file_size) {
 167                         dprint(FD_FILE, "fio extend file %s from %ld to %ld\n",
 168                                f->file_name, sb.st_size, f->real_file_size);
 169                         ret = glfs_ftruncate(g->fd, f->real_file_size);
 170                         if (ret) {
 171                                 log_err("failed fio extend file %s to %ld\n",
 172                                         f->file_name, f->real_file_size);
 173                         } else {
 174                                 unsigned long long left;
 175                                 unsigned int bs;
 176                                 char *b;
 177                                 int r;
 178
 179                                 /* fill the file, copied from extend_file */
 180                                 b = malloc(td->o.max_bs[DDIR_WRITE]);
 181
 182                                 left = f->real_file_size;
 183                                 while (left && !td->terminate) {
 184                                         bs = td->o.max_bs[DDIR_WRITE];
 185                                         if (bs > left)
 186                                                 bs = left;
 187
 188                                         fill_io_buffer(td, b, bs, bs);
 189
 190                                         r = glfs_write(g->fd, b, bs, 0);
 191                                         dprint(FD_IO,
 192                                                "fio write %d of %ld file %s\n",
 193                                                r, f->real_file_size,
 194                                                f->file_name);
 195
 196                                         if (r > 0) {
 197                                                 left -= r;
 198                                                 continue;
 199                                         } else {
 200                                                 if (r < 0) {
 201                                                         int __e = errno;
 202
 203                                                         if (__e == ENOSPC) {
 204                                                                 if (td->o.
 205                                                                     fill_device)
 206                                                                         break;
 207                                                                 log_info
 208                                                                     ("fio: ENOSPC on laying out "
 209                                                                      "file, stopping\n");
 210                                                                 break;
 211                                                         }
 212                                                         td_verror(td, errno,
 213                                                                   "write");
 214                                                 } else
 215                                                         td_verror(td, EIO,
 216                                                                   "write");
 217
 218                                                 break;
 219                                         }
 220                                 }
 221
 222                                 if (b)
 223                                         free(b);
 224                                 glfs_lseek(g->fd, 0, SEEK_SET);
 225
 226                                 if (td->terminate && td->o.unlink) {
 227                                         dprint(FD_FILE, "terminate unlink %s\n",
 228                                                f->file_name);
 229                                         glfs_unlink(g->fs, f->file_name);
 230                                 } else if (td->o.create_fsync) {
 231                                         if (glfs_fsync(g->fd) < 0) {
 232                                                 dprint(FD_FILE,
 233                                                        "failed to sync, close %s\n",
 234                                                        f->file_name);
 235                                                 td_verror(td, errno, "fsync");
 236                                                 glfs_close(g->fd);
 237                                                 g->fd = NULL;
 238                                                 return 1;
 239                                         }
 240                                 }
 241                         }
 242                 }
 243         }
 244 #if defined(GFAPI_USE_FADVISE)
 245         {
 246                 int r = 0;
 247                 if (td_random(td)) {
 248                         r = glfs_fadvise(g->fd, 0, f->real_file_size,
 249                                          POSIX_FADV_RANDOM);
 250                 } else {
 251                         r = glfs_fadvise(g->fd, 0, f->real_file_size,
 252                                          POSIX_FADV_SEQUENTIAL);
 253                 }
 254                 if (r) {
 255                         dprint(FD_FILE, "fio %p fadvise %s status %d\n", g->fs,
 256                                f->file_name, r);
 257                 }
 258         }
 259 #endif
 260         dprint(FD_FILE, "fio %p created %s\n", g->fs, f->file_name);
 261         f->fd = -1;
 262         f->shadow_fd = -1;
 263         td->o.open_files ++;
 264         return ret;
 265 }
 266
 267 int fio_gf_close_file(struct thread_data *td, struct fio_file *f)
 268 {
 269         int ret = 0;
 270         struct gf_data *g = td->io_ops->data;
 271
 272         dprint(FD_FILE, "fd close %s\n", f->file_name);
 273
 274         if (g) {
 275                 if (g->fd && glfs_close(g->fd) < 0)
 276                         ret = errno;
 277                 g->fd = NULL;
 278         }
 279
 280         return ret;
 281 }
 282
 283 int fio_gf_unlink_file(struct thread_data *td, struct fio_file *f)
 284 {
 285         int ret = 0;
 286         struct gf_data *g = td->io_ops->data;
 287
 288         dprint(FD_FILE, "fd unlink %s\n", f->file_name);
 289
 290         if (g) {
 291                 if (g->fd && glfs_close(g->fd) < 0)
 292                         ret = errno;
 293
 294                 glfs_unlink(g->fs, f->file_name);
 295
 296                 if (g->fs)
 297                         glfs_fini(g->fs);
 298
 299                 g->fd = NULL;
 300                 free(g);
 301         }
 302         td->io_ops->data = NULL;
 303
 304         return ret;
 305 }