engines/pmemblk.c

   1 /*
   2  * pmemblk: IO engine that uses NVML libpmemblk to read and write data
   3  *
   4  * Copyright (C) 2016 Hewlett Packard Enterprise Development LP
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License,
   8  * version 2 as published by the Free Software Foundation..
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the Free
  17  * Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307 USA
  19  */
  20
  21 /*
  22  * pmemblk engine
  23  *
  24  * IO engine that uses libpmemblk to read and write data
  25  *
  26  * To use:
  27  *   ioengine=pmemblk
  28  *
  29  * Other relevant settings:
  30  *   iodepth=1
  31  *   direct=1
  32  *   thread=1   REQUIRED
  33  *   unlink=1
  34  *   filename=/pmem0/fiotestfile,BSIZE,FSIZEMB
  35  *
  36  *   thread must be set to 1 for pmemblk as multiple processes cannot
  37  *     open the same block pool file.
  38  *
  39  *   iodepth should be set to 1 as pmemblk is always synchronous.
  40  *   Use numjobs to scale up.
  41  *
  42  *   direct=1 is implied as pmemblk is always direct.
  43  *
  44  *   Can set unlink to 1 to remove the block pool file after testing.
  45  *
  46  *   When specifying the filename, if the block pool file does not already
  47  *   exist, then the pmemblk engine can create the pool file if you specify
  48  *   the block and file sizes.  BSIZE is the block size in bytes.
  49  *   FSIZEMB is the pool file size in MB.
  50  *
  51  *   See examples/pmemblk.fio for more.
  52  *
  53  */
  54
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <unistd.h>
  58 #include <sys/uio.h>
  59 #include <errno.h>
  60 #include <assert.h>
  61 #include <string.h>
  62 #include <libpmem.h>
  63 #include <libpmemblk.h>
  64
  65 #include "../fio.h"
  66
  67 /*
  68  * libpmemblk
  69  */
  70 typedef struct fio_pmemblk_file *fio_pmemblk_file_t;
  71
  72 struct fio_pmemblk_file {
  73         fio_pmemblk_file_t pmb_next;
  74         char *pmb_filename;
  75         uint64_t pmb_refcnt;
  76         PMEMblkpool *pmb_pool;
  77         size_t pmb_bsize;
  78         size_t pmb_nblocks;
  79 };
  80 #define FIOFILEPMBSET(_f, _v)  do {                 \
  81         (_f)->engine_data = (uint64_t)(uintptr_t)(_v);  \
  82 } while(0)
  83 #define FIOFILEPMBGET(_f)  ((fio_pmemblk_file_t)((_f)->engine_data))
  84
  85 static fio_pmemblk_file_t Cache;
  86
  87 static pthread_mutex_t CacheLock = PTHREAD_MUTEX_INITIALIZER;
  88
  89 #define PMB_CREATE   (0x0001)   /* should create file */
  90
  91 fio_pmemblk_file_t fio_pmemblk_cache_lookup(const char *filename)
  92 {
  93         fio_pmemblk_file_t i;
  94
  95         for (i = Cache; i != NULL; i = i->pmb_next)
  96                 if (!strcmp(filename, i->pmb_filename))
  97                         return i;
  98
  99         return NULL;
 100 }
 101
 102 static void fio_pmemblk_cache_insert(fio_pmemblk_file_t pmb)
 103 {
 104         pmb->pmb_next = Cache;
 105         Cache = pmb;
 106 }
 107
 108 static void fio_pmemblk_cache_remove(fio_pmemblk_file_t pmb)
 109 {
 110         fio_pmemblk_file_t i;
 111
 112         if (pmb == Cache) {
 113                 Cache = Cache->pmb_next;
 114                 pmb->pmb_next = NULL;
 115                 return;
 116         }
 117
 118         for (i = Cache; i != NULL; i = i->pmb_next)
 119                 if (pmb == i->pmb_next) {
 120                         i->pmb_next = i->pmb_next->pmb_next;
 121                         pmb->pmb_next = NULL;
 122                         return;
 123                 }
 124 }
 125
 126 /*
 127  * to control block size and gross file size at the libpmemblk
 128  * level, we allow the block size and file size to be appended
 129  * to the file name:
 130  *
 131  *   path[,bsize,fsizemb]
 132  *
 133  * note that we do not use the fio option "filesize" to dictate
 134  * the file size because we can only give libpmemblk the gross
 135  * file size, which is different from the net or usable file
 136  * size (which is probably what fio wants).
 137  *
 138  * the final path without the parameters is returned in ppath.
 139  * the block size and file size are returned in pbsize and fsize.
 140  *
 141  * note that the user should specify the file size in MiB, but
 142  * we return bytes from here.
 143  */
 144 static void pmb_parse_path(const char *pathspec, char **ppath, uint64_t *pbsize,
 145                            uint64_t *pfsize)
 146 {
 147         char *path;
 148         char *s;
 149         uint64_t bsize;
 150         uint64_t fsizemb;
 151
 152         path = strdup(pathspec);
 153         if (!path) {
 154                 *ppath = NULL;
 155                 return;
 156         }
 157
 158         /* extract sizes, if given */
 159         s = strrchr(path, ',');
 160         if (s && (fsizemb = strtoull(s + 1, NULL, 10))) {
 161                 *s = 0;
 162                 s = strrchr(path, ',');
 163                 if (s && (bsize = strtoull(s + 1, NULL, 10))) {
 164                         *s = 0;
 165                         *ppath = path;
 166                         *pbsize = bsize;
 167                         *pfsize = fsizemb << 20;
 168                         return;
 169                 }
 170         }
 171
 172         /* size specs not found */
 173         strcpy(path, pathspec);
 174         *ppath = path;
 175         *pbsize = 0;
 176         *pfsize = 0;
 177 }
 178
 179 static fio_pmemblk_file_t pmb_open(const char *pathspec, int flags)
 180 {
 181         fio_pmemblk_file_t pmb;
 182         char *path = NULL;
 183         uint64_t bsize = 0;
 184         uint64_t fsize = 0;
 185
 186         pmb_parse_path(pathspec, &path, &bsize, &fsize);
 187         if (!path)
 188                 return NULL;
 189
 190         pthread_mutex_lock(&CacheLock);
 191
 192         pmb = fio_pmemblk_cache_lookup(path);
 193         if (!pmb) {
 194                 pmb = malloc(sizeof(*pmb));
 195                 if (!pmb)
 196                         goto error;
 197
 198                 /* try opening existing first, create it if needed */
 199                 pmb->pmb_pool = pmemblk_open(path, bsize);
 200                 if (!pmb->pmb_pool && (errno == ENOENT) &&
 201                     (flags & PMB_CREATE) && (0 < fsize) && (0 < bsize)) {
 202                         pmb->pmb_pool =
 203                             pmemblk_create(path, bsize, fsize, 0644);
 204                 }
 205                 if (!pmb->pmb_pool) {
 206                         log_err("pmemblk: unable to open pmemblk pool file %s (%s)\n",
 207                              path, strerror(errno));
 208                         goto error;
 209                 }
 210
 211                 pmb->pmb_filename = path;
 212                 pmb->pmb_next = NULL;
 213                 pmb->pmb_refcnt = 0;
 214                 pmb->pmb_bsize = pmemblk_bsize(pmb->pmb_pool);
 215                 pmb->pmb_nblocks = pmemblk_nblock(pmb->pmb_pool);
 216
 217                 fio_pmemblk_cache_insert(pmb);
 218         }
 219
 220         pmb->pmb_refcnt += 1;
 221
 222         pthread_mutex_unlock(&CacheLock);
 223
 224         return pmb;
 225
 226 error:
 227         if (pmb) {
 228                 if (pmb->pmb_pool)
 229                         pmemblk_close(pmb->pmb_pool);
 230                 pmb->pmb_pool = NULL;
 231                 pmb->pmb_filename = NULL;
 232                 free(pmb);
 233         }
 234         if (path)
 235                 free(path);
 236
 237         pthread_mutex_unlock(&CacheLock);
 238         return NULL;
 239 }
 240
 241 static void pmb_close(fio_pmemblk_file_t pmb, const bool keep)
 242 {
 243         pthread_mutex_lock(&CacheLock);
 244
 245         pmb->pmb_refcnt--;
 246
 247         if (!keep && !pmb->pmb_refcnt) {
 248                 pmemblk_close(pmb->pmb_pool);
 249                 pmb->pmb_pool = NULL;
 250                 free(pmb->pmb_filename);
 251                 pmb->pmb_filename = NULL;
 252                 fio_pmemblk_cache_remove(pmb);
 253                 free(pmb);
 254         }
 255
 256         pthread_mutex_unlock(&CacheLock);
 257 }
 258
 259 static int pmb_get_flags(struct thread_data *td, uint64_t *pflags)
 260 {
 261         static int thread_warned = 0;
 262         static int odirect_warned = 0;
 263
 264         uint64_t flags = 0;
 265
 266         if (!td->o.use_thread) {
 267                 if (!thread_warned) {
 268                         thread_warned = 1;
 269                         log_err("pmemblk: must set thread=1 for pmemblk engine\n");
 270                 }
 271                 return 1;
 272         }
 273
 274         if (!td->o.odirect && !odirect_warned) {
 275                 odirect_warned = 1;
 276                 log_info("pmemblk: direct == 0, but pmemblk is always direct\n");
 277         }
 278
 279         if (td->o.allow_create)
 280                 flags |= PMB_CREATE;
 281
 282         (*pflags) = flags;
 283         return 0;
 284 }
 285
 286 static int fio_pmemblk_open_file(struct thread_data *td, struct fio_file *f)
 287 {
 288         uint64_t flags = 0;
 289         fio_pmemblk_file_t pmb;
 290
 291         if (pmb_get_flags(td, &flags))
 292                 return 1;
 293
 294         pmb = pmb_open(f->file_name, flags);
 295         if (!pmb)
 296                 return 1;
 297
 298         FIOFILEPMBSET(f, pmb);
 299         return 0;
 300 }
 301
 302 static int fio_pmemblk_close_file(struct thread_data fio_unused *td,
 303                                   struct fio_file *f)
 304 {
 305         fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
 306
 307         if (pmb)
 308                 pmb_close(pmb, false);
 309
 310         FIOFILEPMBSET(f, NULL);
 311         return 0;
 312 }
 313
 314 static int fio_pmemblk_get_file_size(struct thread_data *td, struct fio_file *f)
 315 {
 316         uint64_t flags = 0;
 317         fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
 318
 319         if (fio_file_size_known(f))
 320                 return 0;
 321
 322         if (!pmb) {
 323                 if (pmb_get_flags(td, &flags))
 324                         return 1;
 325                 pmb = pmb_open(f->file_name, flags);
 326                 if (!pmb)
 327                         return 1;
 328         }
 329
 330         f->real_file_size = pmb->pmb_bsize * pmb->pmb_nblocks;
 331
 332         fio_file_set_size_known(f);
 333
 334         if (!FIOFILEPMBGET(f))
 335                 pmb_close(pmb, true);
 336
 337         return 0;
 338 }
 339
 340 static int fio_pmemblk_queue(struct thread_data *td, struct io_u *io_u)
 341 {
 342         struct fio_file *f = io_u->file;
 343         fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
 344
 345         unsigned long long off;
 346         unsigned long len;
 347         void *buf;
 348
 349         fio_ro_check(td, io_u);
 350
 351         switch (io_u->ddir) {
 352         case DDIR_READ:
 353         case DDIR_WRITE:
 354                 off = io_u->offset;
 355                 len = io_u->xfer_buflen;
 356
 357                 io_u->error = EINVAL;
 358                 if (off % pmb->pmb_bsize)
 359                         break;
 360                 if (len % pmb->pmb_bsize)
 361                         break;
 362                 if ((off + len) / pmb->pmb_bsize > pmb->pmb_nblocks)
 363                         break;
 364
 365                 io_u->error = 0;
 366                 buf = io_u->xfer_buf;
 367                 off /= pmb->pmb_bsize;
 368                 len /= pmb->pmb_bsize;
 369                 while (0 < len) {
 370                         if (io_u->ddir == DDIR_READ &&
 371                            0 != pmemblk_read(pmb->pmb_pool, buf, off)) {
 372                                 io_u->error = errno;
 373                                 break;
 374                         } else if (0 != pmemblk_write(pmb->pmb_pool, buf, off)) {
 375                                 io_u->error = errno;
 376                                 break;
 377                         }
 378                         buf += pmb->pmb_bsize;
 379                         off++;
 380                         len--;
 381                 }
 382                 off *= pmb->pmb_bsize;
 383                 len *= pmb->pmb_bsize;
 384                 io_u->resid = io_u->xfer_buflen - (off - io_u->offset);
 385                 break;
 386         case DDIR_SYNC:
 387         case DDIR_DATASYNC:
 388         case DDIR_SYNC_FILE_RANGE:
 389                 /* we're always sync'd */
 390                 io_u->error = 0;
 391                 break;
 392         default:
 393                 io_u->error = EINVAL;
 394                 break;
 395         }
 396
 397         return FIO_Q_COMPLETED;
 398 }
 399
 400 static int fio_pmemblk_unlink_file(struct thread_data *td, struct fio_file *f)
 401 {
 402         char *path = NULL;
 403         uint64_t bsize = 0;
 404         uint64_t fsize = 0;
 405
 406         /*
 407          * we need our own unlink in case the user has specified
 408          * the block and file sizes in the path name.  we parse
 409          * the file_name to determine the file name we actually used.
 410          */
 411
 412         pmb_parse_path(f->file_name, &path, &bsize, &fsize);
 413         if (!path)
 414                 return ENOENT;
 415
 416         unlink(path);
 417         free(path);
 418         return 0;
 419 }
 420
 421 static struct ioengine_ops ioengine = {
 422         .name = "pmemblk",
 423         .version = FIO_IOOPS_VERSION,
 424         .queue = fio_pmemblk_queue,
 425         .open_file = fio_pmemblk_open_file,
 426         .close_file = fio_pmemblk_close_file,
 427         .get_file_size = fio_pmemblk_get_file_size,
 428         .unlink_file = fio_pmemblk_unlink_file,
 429         .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_NOEXTEND | FIO_NODISKUTIL,
 430 };
 431
 432 static void fio_init fio_pmemblk_register(void)
 433 {
 434         register_ioengine(&ioengine);
 435 }
 436
 437 static void fio_exit fio_pmemblk_unregister(void)
 438 {
 439         unregister_ioengine(&ioengine);
 440 }