5439da055f29aaecd7f706dbef85b24487468aa1
[fio.git] / 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  * libpmemblk.so
54  *   By default, the pmemblk engine will let the system find the libpmemblk.so
55  *   that it uses.  You can use an alternative libpmemblk by setting the
56  *   FIO_PMEMBLK_LIB environment variable to the full path to the desired
57  *   libpmemblk.so.
58  *
59  */
60
61 #include <stdio.h>
62 #include <stdlib.h>
63 #include <unistd.h>
64 #include <sys/uio.h>
65 #include <errno.h>
66 #include <assert.h>
67 #include <dlfcn.h>
68 #include <string.h>
69
70 #include "../fio.h"
71
72 /*
73  * libpmemblk
74  */
75 struct PMEMblkpool_s;
76 typedef struct PMEMblkpool_s PMEMblkpool;
77
78 static PMEMblkpool *(*pmemblk_create) (const char *, size_t, size_t, mode_t);
79 static PMEMblkpool *(*pmemblk_open) (const char *, size_t);
80 static void (*pmemblk_close) (PMEMblkpool *);
81 static size_t(*pmemblk_nblock) (PMEMblkpool *);
82 static size_t(*pmemblk_bsize) (PMEMblkpool *);
83 static int (*pmemblk_read) (PMEMblkpool *, void *, off_t);
84 static int (*pmemblk_write) (PMEMblkpool *, const void *, off_t);
85
86 int load_libpmemblk(const char *path)
87 {
88         void *dl;
89
90         if (!path)
91                 path = "libpmemblk.so";
92
93         dl = dlopen(path, RTLD_NOW | RTLD_NODELETE);
94         if (!dl)
95                 goto errorout;
96
97         pmemblk_create = dlsym(dl, "pmemblk_create");
98         if (!pmemblk_create)
99                 goto errorout;
100         pmemblk_open = dlsym(dl, "pmemblk_open");
101         if (!pmemblk_open)
102                 goto errorout;
103         pmemblk_close = dlsym(dl, "pmemblk_close");
104         if (!pmemblk_close)
105                 goto errorout;
106         pmemblk_nblock = dlsym(dl, "pmemblk_nblock");
107         if (!pmemblk_nblock)
108                 goto errorout;
109         pmemblk_bsize = dlsym(dl, "pmemblk_bsize");
110         if (!pmemblk_bsize)
111                 goto errorout;
112         pmemblk_read = dlsym(dl, "pmemblk_read");
113         if (!pmemblk_read)
114                 goto errorout;
115         pmemblk_write = dlsym(dl, "pmemblk_write");
116         if (!pmemblk_write)
117                 goto errorout;
118
119         return 0;
120
121 errorout:
122         log_err("fio: unable to load libpmemblk: %s\n", dlerror());
123         if (dl)
124                 dlclose(dl);
125
126         return -1;
127 }
128
129 typedef struct fio_pmemblk_file *fio_pmemblk_file_t;
130
131 struct fio_pmemblk_file {
132         fio_pmemblk_file_t pmb_next;
133         char *pmb_filename;
134         uint64_t pmb_refcnt;
135         PMEMblkpool *pmb_pool;
136         size_t pmb_bsize;
137         size_t pmb_nblocks;
138 };
139 #define FIOFILEPMBSET(_f, _v)  do {                 \
140         (_f)->engine_data = (uint64_t)(uintptr_t)(_v);  \
141 } while(0)
142 #define FIOFILEPMBGET(_f)  ((fio_pmemblk_file_t)((_f)->engine_data))
143
144 static fio_pmemblk_file_t Cache;
145
146 static pthread_mutex_t CacheLock = PTHREAD_MUTEX_INITIALIZER;
147
148 #define PMB_CREATE   (0x0001)   /* should create file */
149
150 fio_pmemblk_file_t fio_pmemblk_cache_lookup(const char *filename)
151 {
152         fio_pmemblk_file_t i;
153
154         for (i = Cache; i != NULL; i = i->pmb_next)
155                 if (!strcmp(filename, i->pmb_filename))
156                         return i;
157
158         return NULL;
159 }
160
161 static void fio_pmemblk_cache_insert(fio_pmemblk_file_t pmb)
162 {
163         pmb->pmb_next = Cache;
164         Cache = pmb;
165 }
166
167 static void fio_pmemblk_cache_remove(fio_pmemblk_file_t pmb)
168 {
169         fio_pmemblk_file_t i;
170
171         if (pmb == Cache) {
172                 Cache = Cache->pmb_next;
173                 pmb->pmb_next = NULL;
174                 return;
175         }
176
177         for (i = Cache; i != NULL; i = i->pmb_next)
178                 if (pmb == i->pmb_next) {
179                         i->pmb_next = i->pmb_next->pmb_next;
180                         pmb->pmb_next = NULL;
181                         return;
182                 }
183 }
184
185 /*
186  * to control block size and gross file size at the libpmemblk
187  * level, we allow the block size and file size to be appended
188  * to the file name:
189  *
190  *   path[,bsize,fsizemb]
191  *
192  * note that we do not use the fio option "filesize" to dictate
193  * the file size because we can only give libpmemblk the gross
194  * file size, which is different from the net or usable file
195  * size (which is probably what fio wants).
196  *
197  * the final path without the parameters is returned in ppath.
198  * the block size and file size are returned in pbsize and fsize.
199  *
200  * note that the user should specify the file size in MiB, but
201  * we return bytes from here.
202  */
203 static void pmb_parse_path(const char *pathspec, char **ppath, uint64_t *pbsize,
204                            uint64_t *pfsize)
205 {
206         char *path;
207         char *s;
208         uint64_t bsize;
209         uint64_t fsizemb;
210
211         path = strdup(pathspec);
212         if (!path) {
213                 *ppath = NULL;
214                 return;
215         }
216
217         /* extract sizes, if given */
218         s = strrchr(path, ',');
219         if (s && (fsizemb = strtoull(s + 1, NULL, 10))) {
220                 *s = 0;
221                 s = strrchr(path, ',');
222                 if (s && (bsize = strtoull(s + 1, NULL, 10))) {
223                         *s = 0;
224                         *ppath = path;
225                         *pbsize = bsize;
226                         *pfsize = fsizemb << 20;
227                         return;
228                 }
229         }
230
231         /* size specs not found */
232         strcpy(path, pathspec);
233         *ppath = path;
234         *pbsize = 0;
235         *pfsize = 0;
236 }
237
238 static fio_pmemblk_file_t pmb_open(const char *pathspec, int flags)
239 {
240         fio_pmemblk_file_t pmb;
241         char *path = NULL;
242         uint64_t bsize = 0;
243         uint64_t fsize = 0;
244
245         pmb_parse_path(pathspec, &path, &bsize, &fsize);
246         if (!path)
247                 return NULL;
248
249         pthread_mutex_lock(&CacheLock);
250
251         pmb = fio_pmemblk_cache_lookup(path);
252         if (!pmb) {
253                 /* load libpmemblk if needed */
254                 if (!pmemblk_open)
255                         if (load_libpmemblk(getenv("FIO_PMEMBLK_LIB")))
256                                 goto error;
257
258                 pmb = malloc(sizeof(*pmb));
259                 if (!pmb)
260                         goto error;
261
262                 /* try opening existing first, create it if needed */
263                 pmb->pmb_pool = pmemblk_open(path, bsize);
264                 if (!pmb->pmb_pool && (errno == ENOENT) &&
265                     (flags & PMB_CREATE) && (0 < fsize) && (0 < bsize)) {
266                         pmb->pmb_pool =
267                             pmemblk_create(path, bsize, fsize, 0644);
268                 }
269                 if (!pmb->pmb_pool) {
270                         log_err
271                             ("fio: enable to open pmemblk pool file (errno %d)\n",
272                              errno);
273                         goto error;
274                 }
275
276                 pmb->pmb_filename = path;
277                 pmb->pmb_next = NULL;
278                 pmb->pmb_refcnt = 0;
279                 pmb->pmb_bsize = pmemblk_bsize(pmb->pmb_pool);
280                 pmb->pmb_nblocks = pmemblk_nblock(pmb->pmb_pool);
281
282                 fio_pmemblk_cache_insert(pmb);
283         }
284
285         pmb->pmb_refcnt += 1;
286
287         pthread_mutex_unlock(&CacheLock);
288
289         return pmb;
290
291 error:
292         if (pmb) {
293                 if (pmb->pmb_pool)
294                         pmemblk_close(pmb->pmb_pool);
295                 pmb->pmb_pool = NULL;
296                 pmb->pmb_filename = NULL;
297                 free(pmb);
298         }
299         if (path)
300                 free(path);
301
302         pthread_mutex_unlock(&CacheLock);
303         return NULL;
304 }
305
306 static void pmb_close(fio_pmemblk_file_t pmb, const bool keep)
307 {
308         pthread_mutex_lock(&CacheLock);
309
310         pmb->pmb_refcnt--;
311
312         if (!keep && !pmb->pmb_refcnt) {
313                 pmemblk_close(pmb->pmb_pool);
314                 pmb->pmb_pool = NULL;
315                 free(pmb->pmb_filename);
316                 pmb->pmb_filename = NULL;
317                 fio_pmemblk_cache_remove(pmb);
318                 free(pmb);
319         }
320
321         pthread_mutex_unlock(&CacheLock);
322 }
323
324 static int pmb_get_flags(struct thread_data *td, uint64_t *pflags)
325 {
326         static int thread_warned = 0;
327         static int odirect_warned = 0;
328
329         uint64_t flags = 0;
330
331         if (!td->o.use_thread) {
332                 if (!thread_warned) {
333                         thread_warned = 1;
334                         log_err("fio: must set thread=1 for pmemblk engine\n");
335                 }
336                 return 1;
337         }
338
339         if (!td->o.odirect && !odirect_warned) {
340                 odirect_warned = 1;
341                 log_info("fio: direct == 0, but pmemblk is always direct\n");
342         }
343
344         if (td->o.allow_create)
345                 flags |= PMB_CREATE;
346
347         (*pflags) = flags;
348         return 0;
349 }
350
351 static int fio_pmemblk_open_file(struct thread_data *td, struct fio_file *f)
352 {
353         uint64_t flags = 0;
354         fio_pmemblk_file_t pmb;
355
356         if (pmb_get_flags(td, &flags))
357                 return 1;
358
359         pmb = pmb_open(f->file_name, flags);
360         if (!pmb)
361                 return 1;
362
363         FIOFILEPMBSET(f, pmb);
364         return 0;
365 }
366
367 static int fio_pmemblk_close_file(struct thread_data fio_unused *td,
368                                   struct fio_file *f)
369 {
370         fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
371
372         if (pmb)
373                 pmb_close(pmb, false);
374
375         FIOFILEPMBSET(f, NULL);
376         return 0;
377 }
378
379 static int fio_pmemblk_get_file_size(struct thread_data *td, struct fio_file *f)
380 {
381         uint64_t flags = 0;
382         fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
383
384         if (fio_file_size_known(f))
385                 return 0;
386
387         if (!pmb) {
388                 if (pmb_get_flags(td, &flags))
389                         return 1;
390                 pmb = pmb_open(f->file_name, flags);
391                 if (!pmb)
392                         return 1;
393         }
394
395         f->real_file_size = pmb->pmb_bsize * pmb->pmb_nblocks;
396
397         fio_file_set_size_known(f);
398
399         if (!FIOFILEPMBGET(f))
400                 pmb_close(pmb, true);
401
402         return 0;
403 }
404
405 static int fio_pmemblk_queue(struct thread_data *td, struct io_u *io_u)
406 {
407         struct fio_file *f = io_u->file;
408         fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
409
410         unsigned long long off;
411         unsigned long len;
412         void *buf;
413         int (*blkop) (PMEMblkpool *, void *, off_t) = (void *)pmemblk_write;
414
415         fio_ro_check(td, io_u);
416
417         switch (io_u->ddir) {
418         case DDIR_READ:
419                 blkop = pmemblk_read;
420                 /* fall through */
421         case DDIR_WRITE:
422                 off = io_u->offset;
423                 len = io_u->xfer_buflen;
424
425                 io_u->error = EINVAL;
426                 if (off % pmb->pmb_bsize)
427                         break;
428                 if (len % pmb->pmb_bsize)
429                         break;
430                 if ((off + len) / pmb->pmb_bsize > pmb->pmb_nblocks)
431                         break;
432
433                 io_u->error = 0;
434                 buf = io_u->xfer_buf;
435                 off /= pmb->pmb_bsize;
436                 len /= pmb->pmb_bsize;
437                 while (0 < len) {
438                         if (0 != blkop(pmb->pmb_pool, buf, off)) {
439                                 io_u->error = errno;
440                                 break;
441                         }
442                         buf += pmb->pmb_bsize;
443                         off++;
444                         len--;
445                 }
446                 off *= pmb->pmb_bsize;
447                 len *= pmb->pmb_bsize;
448                 io_u->resid = io_u->xfer_buflen - (off - io_u->offset);
449                 break;
450         case DDIR_SYNC:
451         case DDIR_DATASYNC:
452         case DDIR_SYNC_FILE_RANGE:
453                 /* we're always sync'd */
454                 io_u->error = 0;
455                 break;
456         default:
457                 io_u->error = EINVAL;
458                 break;
459         }
460
461         return FIO_Q_COMPLETED;
462 }
463
464 static int fio_pmemblk_unlink_file(struct thread_data *td, struct fio_file *f)
465 {
466         char *path = NULL;
467         uint64_t bsize = 0;
468         uint64_t fsize = 0;
469
470         /*
471          * we need our own unlink in case the user has specified
472          * the block and file sizes in the path name.  we parse
473          * the file_name to determine the file name we actually used.
474          */
475
476         pmb_parse_path(f->file_name, &path, &bsize, &fsize);
477         if (!path)
478                 return ENOENT;
479
480         unlink(path);
481         free(path);
482         return 0;
483 }
484
485 static struct ioengine_ops ioengine = {
486         .name = "pmemblk",
487         .version = FIO_IOOPS_VERSION,
488         .queue = fio_pmemblk_queue,
489         .open_file = fio_pmemblk_open_file,
490         .close_file = fio_pmemblk_close_file,
491         .get_file_size = fio_pmemblk_get_file_size,
492         .unlink_file = fio_pmemblk_unlink_file,
493         .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_NOEXTEND | FIO_NODISKUTIL,
494 };
495
496 static void fio_init fio_pmemblk_register(void)
497 {
498         register_ioengine(&ioengine);
499 }
500
501 static void fio_exit fio_pmemblk_unregister(void)
502 {
503         unregister_ioengine(&ioengine);
504 }