engines/dev-dax.c

   1 /*
   2  * device DAX engine
   3  *
   4  * IO engine that reads/writes from files by doing memcpy to/from
   5  * a memory mapped region of DAX enabled device.
   6  *
   7  * Copyright (C) 2016 Intel Corp
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License,
  11  * version 2 as published by the Free Software Foundation..
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  */
  19
  20 /*
  21  * device dax engine
  22  * IO engine that access a DAX device directly for read and write data
  23  *
  24  * To use:
  25  *   ioengine=dev-dax
  26  *
  27  *   Other relevant settings:
  28  *     iodepth=1
  29  *     direct=0    REQUIRED
  30  *     filename=/dev/daxN.N
  31  *     bs=2m
  32  *
  33  *     direct should be left to 0. Using dev-dax implies that memory access
  34  *     is direct. However, dev-dax does not support O_DIRECT flag by design
  35  *     since it is not necessary.
  36  *
  37  *     bs should adhere to the device dax alignment at minimally.
  38  *
  39  * libpmem.so
  40  *   By default, the dev-dax engine will let the system find the libpmem.so
  41  *   that it uses. You can use an alternative libpmem by setting the
  42  *   FIO_PMEM_LIB environment variable to the full path to the desired
  43  *   libpmem.so.
  44  */
  45
  46 #include <stdio.h>
  47 #include <limits.h>
  48 #include <stdlib.h>
  49 #include <unistd.h>
  50 #include <errno.h>
  51 #include <sys/mman.h>
  52 #include <sys/stat.h>
  53 #include <sys/sysmacros.h>
  54 #include <libgen.h>
  55 #include <libpmem.h>
  56
  57 #include "../fio.h"
  58 #include "../verify.h"
  59
  60 /*
  61  * Limits us to 1GiB of mapped files in total to model after
  62  * mmap engine behavior
  63  */
  64 #define MMAP_TOTAL_SZ   (1 * 1024 * 1024 * 1024UL)
  65
  66 struct fio_devdax_data {
  67         void *devdax_ptr;
  68         size_t devdax_sz;
  69         off_t devdax_off;
  70 };
  71
  72 static int fio_devdax_file(struct thread_data *td, struct fio_file *f,
  73                            size_t length, off_t off)
  74 {
  75         struct fio_devdax_data *fdd = FILE_ENG_DATA(f);
  76         int flags = 0;
  77
  78         if (td_rw(td))
  79                 flags = PROT_READ | PROT_WRITE;
  80         else if (td_write(td)) {
  81                 flags = PROT_WRITE;
  82
  83                 if (td->o.verify != VERIFY_NONE)
  84                         flags |= PROT_READ;
  85         } else
  86                 flags = PROT_READ;
  87
  88         fdd->devdax_ptr = mmap(NULL, length, flags, MAP_SHARED, f->fd, off);
  89         if (fdd->devdax_ptr == MAP_FAILED) {
  90                 fdd->devdax_ptr = NULL;
  91                 td_verror(td, errno, "mmap");
  92         }
  93
  94         if (td->error && fdd->devdax_ptr)
  95                 munmap(fdd->devdax_ptr, length);
  96
  97         return td->error;
  98 }
  99
 100 /*
 101  * Just mmap an appropriate portion, we cannot mmap the full extent
 102  */
 103 static int fio_devdax_prep_limited(struct thread_data *td, struct io_u *io_u)
 104 {
 105         struct fio_file *f = io_u->file;
 106         struct fio_devdax_data *fdd = FILE_ENG_DATA(f);
 107
 108         if (io_u->buflen > f->real_file_size) {
 109                 log_err("dev-dax: bs too big for dev-dax engine\n");
 110                 return EIO;
 111         }
 112
 113         fdd->devdax_sz = min(MMAP_TOTAL_SZ, f->real_file_size);
 114         if (fdd->devdax_sz > f->io_size)
 115                 fdd->devdax_sz = f->io_size;
 116
 117         fdd->devdax_off = io_u->offset;
 118
 119         return fio_devdax_file(td, f, fdd->devdax_sz, fdd->devdax_off);
 120 }
 121
 122 /*
 123  * Attempt to mmap the entire file
 124  */
 125 static int fio_devdax_prep_full(struct thread_data *td, struct io_u *io_u)
 126 {
 127         struct fio_file *f = io_u->file;
 128         struct fio_devdax_data *fdd = FILE_ENG_DATA(f);
 129         int ret;
 130
 131         if (fio_file_partial_mmap(f))
 132                 return EINVAL;
 133
 134         if (io_u->offset != (size_t) io_u->offset ||
 135             f->io_size != (size_t) f->io_size) {
 136                 fio_file_set_partial_mmap(f);
 137                 return EINVAL;
 138         }
 139
 140         fdd->devdax_sz = f->io_size;
 141         fdd->devdax_off = 0;
 142
 143         ret = fio_devdax_file(td, f, fdd->devdax_sz, fdd->devdax_off);
 144         if (ret)
 145                 fio_file_set_partial_mmap(f);
 146
 147         return ret;
 148 }
 149
 150 static int fio_devdax_prep(struct thread_data *td, struct io_u *io_u)
 151 {
 152         struct fio_file *f = io_u->file;
 153         struct fio_devdax_data *fdd = FILE_ENG_DATA(f);
 154         int ret;
 155
 156         /*
 157          * It fits within existing mapping, use it
 158          */
 159         if (io_u->offset >= fdd->devdax_off &&
 160             io_u->offset + io_u->buflen < fdd->devdax_off + fdd->devdax_sz)
 161                 goto done;
 162
 163         /*
 164          * unmap any existing mapping
 165          */
 166         if (fdd->devdax_ptr) {
 167                 if (munmap(fdd->devdax_ptr, fdd->devdax_sz) < 0)
 168                         return errno;
 169                 fdd->devdax_ptr = NULL;
 170         }
 171
 172         if (fio_devdax_prep_full(td, io_u)) {
 173                 td_clear_error(td);
 174                 ret = fio_devdax_prep_limited(td, io_u);
 175                 if (ret)
 176                         return ret;
 177         }
 178
 179 done:
 180         io_u->mmap_data = fdd->devdax_ptr + io_u->offset - fdd->devdax_off -
 181                                 f->file_offset;
 182         return 0;
 183 }
 184
 185 static int fio_devdax_queue(struct thread_data *td, struct io_u *io_u)
 186 {
 187         fio_ro_check(td, io_u);
 188         io_u->error = 0;
 189
 190         switch (io_u->ddir) {
 191         case DDIR_READ:
 192                 memcpy(io_u->xfer_buf, io_u->mmap_data, io_u->xfer_buflen);
 193                 break;
 194         case DDIR_WRITE:
 195                 pmem_memcpy_persist(io_u->mmap_data, io_u->xfer_buf,
 196                                     io_u->xfer_buflen);
 197                 break;
 198         case DDIR_SYNC:
 199         case DDIR_DATASYNC:
 200         case DDIR_SYNC_FILE_RANGE:
 201                 break;
 202         default:
 203                 io_u->error = EINVAL;
 204                 break;
 205         }
 206
 207         return FIO_Q_COMPLETED;
 208 }
 209
 210 static int fio_devdax_init(struct thread_data *td)
 211 {
 212         struct thread_options *o = &td->o;
 213
 214         if ((o->rw_min_bs & page_mask) &&
 215             (o->fsync_blocks || o->fdatasync_blocks)) {
 216                 log_err("dev-dax: mmap options dictate a minimum block size of %llu bytes\n",
 217                         (unsigned long long) page_size);
 218                 return 1;
 219         }
 220
 221         return 0;
 222 }
 223
 224 static int fio_devdax_open_file(struct thread_data *td, struct fio_file *f)
 225 {
 226         struct fio_devdax_data *fdd;
 227         int ret;
 228
 229         ret = generic_open_file(td, f);
 230         if (ret)
 231                 return ret;
 232
 233         fdd = calloc(1, sizeof(*fdd));
 234         if (!fdd) {
 235                 int fio_unused __ret;
 236                 __ret = generic_close_file(td, f);
 237                 return 1;
 238         }
 239
 240         FILE_SET_ENG_DATA(f, fdd);
 241
 242         return 0;
 243 }
 244
 245 static int fio_devdax_close_file(struct thread_data *td, struct fio_file *f)
 246 {
 247         struct fio_devdax_data *fdd = FILE_ENG_DATA(f);
 248
 249         FILE_SET_ENG_DATA(f, NULL);
 250         free(fdd);
 251         fio_file_clear_partial_mmap(f);
 252
 253         return generic_close_file(td, f);
 254 }
 255
 256 static int
 257 fio_devdax_get_file_size(struct thread_data *td, struct fio_file *f)
 258 {
 259         char spath[PATH_MAX];
 260         char npath[PATH_MAX];
 261         char *rpath;
 262         FILE *sfile;
 263         uint64_t size;
 264         struct stat st;
 265         int rc;
 266
 267         if (fio_file_size_known(f))
 268                 return 0;
 269
 270         if (f->filetype != FIO_TYPE_CHAR)
 271                 return -EINVAL;
 272
 273         rc = stat(f->file_name, &st);
 274         if (rc < 0) {
 275                 log_err("%s: failed to stat file %s (%s)\n",
 276                         td->o.name, f->file_name, strerror(errno));
 277                 return -errno;
 278         }
 279
 280         snprintf(spath, PATH_MAX, "/sys/dev/char/%d:%d/subsystem",
 281                  major(st.st_rdev), minor(st.st_rdev));
 282
 283         rpath = realpath(spath, npath);
 284         if (!rpath) {
 285                 log_err("%s: realpath on %s failed (%s)\n",
 286                         td->o.name, spath, strerror(errno));
 287                 return -errno;
 288         }
 289
 290         /* check if DAX device */
 291         if (strcmp("/sys/class/dax", rpath)) {
 292                 log_err("%s: %s not a DAX device!\n",
 293                         td->o.name, f->file_name);
 294         }
 295
 296         snprintf(spath, PATH_MAX, "/sys/dev/char/%d:%d/size",
 297                  major(st.st_rdev), minor(st.st_rdev));
 298
 299         sfile = fopen(spath, "r");
 300         if (!sfile) {
 301                 log_err("%s: fopen on %s failed (%s)\n",
 302                         td->o.name, spath, strerror(errno));
 303                 return 1;
 304         }
 305
 306         rc = fscanf(sfile, "%lu", &size);
 307         if (rc < 0) {
 308                 log_err("%s: fscanf on %s failed (%s)\n",
 309                         td->o.name, spath, strerror(errno));
 310                 return 1;
 311         }
 312
 313         f->real_file_size = size;
 314
 315         fclose(sfile);
 316
 317         if (f->file_offset > f->real_file_size) {
 318                 log_err("%s: offset extends end (%llu > %llu)\n", td->o.name,
 319                                         (unsigned long long) f->file_offset,
 320                                         (unsigned long long) f->real_file_size);
 321                 return 1;
 322         }
 323
 324         fio_file_set_size_known(f);
 325         return 0;
 326 }
 327
 328 static struct ioengine_ops ioengine = {
 329         .name           = "dev-dax",
 330         .version        = FIO_IOOPS_VERSION,
 331         .init           = fio_devdax_init,
 332         .prep           = fio_devdax_prep,
 333         .queue          = fio_devdax_queue,
 334         .open_file      = fio_devdax_open_file,
 335         .close_file     = fio_devdax_close_file,
 336         .get_file_size  = fio_devdax_get_file_size,
 337         .flags          = FIO_SYNCIO | FIO_DISKLESSIO | FIO_NOEXTEND | FIO_NODISKUTIL,
 338 };
 339
 340 static void fio_init fio_devdax_register(void)
 341 {
 342         register_ioengine(&ioengine);
 343 }
 344
 345 static void fio_exit fio_devdax_unregister(void)
 346 {
 347         unregister_ioengine(&ioengine);
 348 }