X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=engines%2Fpmemblk.c;h=ca72697819511dc1190658bc687d2f5534f621f4;hb=39d13e67ef1f4b327c68431f8daf033a03920117;hp=c28a1d97d48a04567188c462748379e2b1450092;hpb=43f3cec2e958691d67404b01976f854281af6841;p=fio.git

diff --git a/engines/pmemblk.c b/engines/pmemblk.c
index c28a1d97..ca726978 100644
--- a/engines/pmemblk.c
+++ b/engines/pmemblk.c
@@ -18,19 +18,13 @@
  * Boston, MA 02111-1307 USA
  */
 
-
 /*
  * pmemblk engine
  *
  * IO engine that uses libpmemblk to read and write data
  *
- * To build as an external engine:
- *   Copy pmemblk.c to the engines/ directory of the fio source code, then:
- *   cd .../engines/
- *   gcc -Wall -shared -rdynamic -fPIC -o pmemblk.o -D_GNU_SOURCE pmemblk.c
- *
- * To use as an external engine:
- *   ioengine=/full/path/to/pmemblk.o
+ * To use:
+ *   ioengine=pmemblk
  *
  * Other relevant settings:
  *   iodepth=1
@@ -54,6 +48,8 @@
  *   the block and file sizes.  BSIZE is the block size in bytes.
  *   FSIZEMB is the pool file size in MB.
  *
+ *   See examples/pmemblk.fio for more.
+ *
  * libpmemblk.so
  *   By default, the pmemblk engine will let the system find the libpmemblk.so
  *   that it uses.  You can use an alternative libpmemblk by setting the
@@ -73,131 +69,104 @@
 
 #include "../fio.h"
 
-
-
 /*
  * libpmemblk
  */
 struct PMEMblkpool_s;
 typedef struct PMEMblkpool_s PMEMblkpool;
 
-PMEMblkpool* (*pmemblk_create_ptr)(const char*, size_t, size_t, mode_t) = NULL;
-PMEMblkpool* (*pmemblk_open_ptr)(const char*, size_t) = NULL;
-void (*pmemblk_close_ptr)(PMEMblkpool*) = NULL;
-size_t (*pmemblk_nblock_ptr)(PMEMblkpool*) = NULL;
-size_t (*pmemblk_bsize_ptr)(PMEMblkpool*) = NULL;
-int (*pmemblk_read_ptr)(PMEMblkpool*, void*, off_t) = NULL;
-int (*pmemblk_write_ptr)(PMEMblkpool*, const void*, off_t) = NULL;
-
-int
-load_libpmemblk(
-	const char* path
-)
+static PMEMblkpool *(*pmemblk_create) (const char *, size_t, size_t, mode_t);
+static PMEMblkpool *(*pmemblk_open) (const char *, size_t);
+static void (*pmemblk_close) (PMEMblkpool *);
+static size_t(*pmemblk_nblock) (PMEMblkpool *);
+static size_t(*pmemblk_bsize) (PMEMblkpool *);
+static int (*pmemblk_read) (PMEMblkpool *, void *, off_t);
+static int (*pmemblk_write) (PMEMblkpool *, const void *, off_t);
+
+int load_libpmemblk(const char *path)
 {
-	void*   dl;
+	void *dl;
 
-	if (NULL == path)
+	if (!path)
 		path = "libpmemblk.so";
 
 	dl = dlopen(path, RTLD_NOW | RTLD_NODELETE);
-	if (NULL == dl)
+	if (!dl)
 		goto errorout;
 
-	if (NULL == (pmemblk_create_ptr = dlsym(dl, "pmemblk_create")))
+	pmemblk_create = dlsym(dl, "pmemblk_create");
+	if (!pmemblk_create)
 		goto errorout;
-	if (NULL == (pmemblk_open_ptr = dlsym(dl, "pmemblk_open")))
+	pmemblk_open = dlsym(dl, "pmemblk_open");
+	if (!pmemblk_open)
 		goto errorout;
-	if (NULL == (pmemblk_close_ptr = dlsym(dl, "pmemblk_close")))
+	pmemblk_close = dlsym(dl, "pmemblk_close");
+	if (!pmemblk_close)
 		goto errorout;
-	if (NULL == (pmemblk_nblock_ptr = dlsym(dl, "pmemblk_nblock")))
+	pmemblk_nblock = dlsym(dl, "pmemblk_nblock");
+	if (!pmemblk_nblock)
 		goto errorout;
-	if (NULL == (pmemblk_bsize_ptr = dlsym(dl, "pmemblk_bsize")))
+	pmemblk_bsize = dlsym(dl, "pmemblk_bsize");
+	if (!pmemblk_bsize)
 		goto errorout;
-	if (NULL == (pmemblk_read_ptr = dlsym(dl, "pmemblk_read")))
+	pmemblk_read = dlsym(dl, "pmemblk_read");
+	if (!pmemblk_read)
 		goto errorout;
-	if (NULL == (pmemblk_write_ptr = dlsym(dl, "pmemblk_write")))
+	pmemblk_write = dlsym(dl, "pmemblk_write");
+	if (!pmemblk_write)
 		goto errorout;
-	
+
 	return 0;
 
 errorout:
 	log_err("fio: unable to load libpmemblk: %s\n", dlerror());
-	if (NULL != dl)
+	if (dl)
 		dlclose(dl);
 
-	return (-1);
-	
-}  /* load_libpmemblk() */
-
-#define pmemblk_create   pmemblk_create_ptr
-#define pmemblk_open     pmemblk_open_ptr
-#define pmemblk_close    pmemblk_close_ptr
-#define pmemblk_nblock   pmemblk_nblock_ptr
-#define pmemblk_bsize    pmemblk_bsize_ptr
-#define pmemblk_read     pmemblk_read_ptr
-#define pmemblk_write    pmemblk_write_ptr
+	return -1;
+}
 
+typedef struct fio_pmemblk_file *fio_pmemblk_file_t;
 
-typedef struct fio_pmemblk_file*   fio_pmemblk_file_t;
 struct fio_pmemblk_file {
-	fio_pmemblk_file_t   pmb_next;
-	char*                pmb_filename;
-	uint64_t             pmb_refcnt;
-	PMEMblkpool*         pmb_pool;
-	size_t               pmb_bsize;
-	size_t               pmb_nblocks;
+	fio_pmemblk_file_t pmb_next;
+	char *pmb_filename;
+	uint64_t pmb_refcnt;
+	PMEMblkpool *pmb_pool;
+	size_t pmb_bsize;
+	size_t pmb_nblocks;
 };
 #define FIOFILEPMBSET(_f, _v)  do {                 \
 	(_f)->engine_data = (uint64_t)(uintptr_t)(_v);  \
 } while(0)
 #define FIOFILEPMBGET(_f)  ((fio_pmemblk_file_t)((_f)->engine_data))
 
-static fio_pmemblk_file_t   Cache = NULL;
-
-static pthread_mutex_t      CacheLock = PTHREAD_MUTEX_INITIALIZER;
-#define CACHE_LOCK()  \
-	(void)pthread_mutex_lock(&CacheLock)
-#define CACHE_UNLOCK()  \
-	(void)pthread_mutex_unlock(&CacheLock)
+static fio_pmemblk_file_t Cache;
 
-#define PMB_CREATE   (0x0001)  /* should create file */
+static pthread_mutex_t CacheLock = PTHREAD_MUTEX_INITIALIZER;
 
+#define PMB_CREATE   (0x0001)	/* should create file */
 
-fio_pmemblk_file_t
-fio_pmemblk_cache_lookup(
-	const char* filename
-)
+fio_pmemblk_file_t fio_pmemblk_cache_lookup(const char *filename)
 {
-	fio_pmemblk_file_t   i;
+	fio_pmemblk_file_t i;
 
 	for (i = Cache; i != NULL; i = i->pmb_next)
-		if (0 == strcmp(filename, i->pmb_filename))
+		if (!strcmp(filename, i->pmb_filename))
 			return i;
 
 	return NULL;
+}
 
-}  /* fio_pmemblk_cache_lookup() */
-
-
-static void
-fio_pmemblk_cache_insert(
-	fio_pmemblk_file_t pmb
-)
+static void fio_pmemblk_cache_insert(fio_pmemblk_file_t pmb)
 {
 	pmb->pmb_next = Cache;
 	Cache = pmb;
+}
 
-	return;
-
-}  /* fio_pmemblk_cache_insert() */
-
-
-static void
-fio_pmemblk_cache_remove(
-	fio_pmemblk_file_t pmb
-)
+static void fio_pmemblk_cache_remove(fio_pmemblk_file_t pmb)
 {
-	fio_pmemblk_file_t   i;
+	fio_pmemblk_file_t i;
 
 	if (pmb == Cache) {
 		Cache = Cache->pmb_next;
@@ -211,11 +180,7 @@ fio_pmemblk_cache_remove(
 			pmb->pmb_next = NULL;
 			return;
 		}
-
-	return;
-
-}  /* fio_pmemblk_cache_remove() */
-
+}
 
 /*
  * to control block size and gross file size at the libpmemblk
@@ -235,33 +200,28 @@ fio_pmemblk_cache_remove(
  * note that the user should specify the file size in MiB, but
  * we return bytes from here.
  */
-static void
-pmb_parse_path(
-	const char* pathspec,
-	char**      ppath,
-	uint64_t*   pbsize,
-	uint64_t*   pfsize
-)
+static void pmb_parse_path(const char *pathspec, char **ppath, uint64_t *pbsize,
+			   uint64_t *pfsize)
 {
-	char*      path;
-	char*      s;
-	uint64_t   bsize;
-	uint64_t   fsizemb;
+	char *path;
+	char *s;
+	uint64_t bsize;
+	uint64_t fsizemb;
 
 	path = strdup(pathspec);
-	if (NULL == path) {
+	if (!path) {
 		*ppath = NULL;
 		return;
 	}
 
 	/* extract sizes, if given */
 	s = strrchr(path, ',');
-	if (s && (fsizemb = strtoull(s+1, NULL, 10))) {
+	if (s && (fsizemb = strtoull(s + 1, NULL, 10))) {
 		*s = 0;
 		s = strrchr(path, ',');
-		if (s && (bsize = strtoull(s+1, NULL, 10))) {
+		if (s && (bsize = strtoull(s + 1, NULL, 10))) {
 			*s = 0;
-			*ppath  = path;
+			*ppath = path;
 			*pbsize = bsize;
 			*pfsize = fsizemb << 20;
 			return;
@@ -270,101 +230,86 @@ pmb_parse_path(
 
 	/* size specs not found */
 	strcpy(path, pathspec);
-	*ppath  = path;
+	*ppath = path;
 	*pbsize = 0;
 	*pfsize = 0;
-	return;
-
-}  /* pmb_parse_path() */
-
+}
 
-static
-fio_pmemblk_file_t
-pmb_open(
-	const char* pathspec,
-	int         flags
-)
+static fio_pmemblk_file_t pmb_open(const char *pathspec, int flags)
 {
-	fio_pmemblk_file_t   pmb;
-	char*                path  = NULL;
-	uint64_t             bsize = 0;
-	uint64_t             fsize = 0;
+	fio_pmemblk_file_t pmb;
+	char *path = NULL;
+	uint64_t bsize = 0;
+	uint64_t fsize = 0;
 
 	pmb_parse_path(pathspec, &path, &bsize, &fsize);
-	if (NULL == path)
+	if (!path)
 		return NULL;
 
-	CACHE_LOCK();
+	pthread_mutex_lock(&CacheLock);
 
 	pmb = fio_pmemblk_cache_lookup(path);
-
-	if (NULL == pmb) {
+	if (!pmb) {
 		/* load libpmemblk if needed */
-		if (NULL == pmemblk_open)
-			if (0 != load_libpmemblk(getenv("FIO_PMEMBLK_LIB")))
+		if (!pmemblk_open)
+			if (load_libpmemblk(getenv("FIO_PMEMBLK_LIB")))
 				goto error;
 
 		pmb = malloc(sizeof(*pmb));
-		if (NULL == pmb)
+		if (!pmb)
 			goto error;
 
 		/* try opening existing first, create it if needed */
 		pmb->pmb_pool = pmemblk_open(path, bsize);
-		if ((NULL == pmb->pmb_pool) &&
-		    (ENOENT == errno) &&
-		    (flags & PMB_CREATE) &&
-		    (0 < fsize) &&
-		    (0 < bsize)) {
-			pmb->pmb_pool = pmemblk_create(path, bsize, fsize, 0644);
+		if (!pmb->pmb_pool && (errno == ENOENT) &&
+		    (flags & PMB_CREATE) && (0 < fsize) && (0 < bsize)) {
+			pmb->pmb_pool =
+			    pmemblk_create(path, bsize, fsize, 0644);
 		}
-		if (NULL == pmb->pmb_pool) {
-			log_err("fio: enable to open pmemblk pool file (errno %d)\n",
-			        errno);
+		if (!pmb->pmb_pool) {
+			log_err
+			    ("fio: enable to open pmemblk pool file (errno %d)\n",
+			     errno);
 			goto error;
 		}
 
 		pmb->pmb_filename = path;
-		pmb->pmb_next     = NULL;
-		pmb->pmb_refcnt   = 0;
-		pmb->pmb_bsize    = pmemblk_bsize(pmb->pmb_pool);
-		pmb->pmb_nblocks  = pmemblk_nblock(pmb->pmb_pool);
+		pmb->pmb_next = NULL;
+		pmb->pmb_refcnt = 0;
+		pmb->pmb_bsize = pmemblk_bsize(pmb->pmb_pool);
+		pmb->pmb_nblocks = pmemblk_nblock(pmb->pmb_pool);
 
 		fio_pmemblk_cache_insert(pmb);
 	}
 
 	pmb->pmb_refcnt += 1;
 
-	CACHE_UNLOCK();
-	
+	pthread_mutex_unlock(&CacheLock);
+
 	return pmb;
 
 error:
-	if (NULL != pmb) {
-		if (NULL != pmb->pmb_pool)
+	if (pmb) {
+		if (pmb->pmb_pool)
 			pmemblk_close(pmb->pmb_pool);
-		pmb->pmb_pool     = NULL;
+		pmb->pmb_pool = NULL;
 		pmb->pmb_filename = NULL;
 		free(pmb);
 	}
-	if (NULL != path)
+	if (path)
 		free(path);
-	CACHE_UNLOCK();
-	return NULL;
-
-}  /* pmb_open() */
 
+	pthread_mutex_unlock(&CacheLock);
+	return NULL;
+}
 
-static void
-pmb_close(
-	fio_pmemblk_file_t pmb,
-	const int          keep
-)
+static void pmb_close(fio_pmemblk_file_t pmb, const bool keep)
 {
-	CACHE_LOCK();
+	pthread_mutex_lock(&CacheLock);
 
 	pmb->pmb_refcnt--;
 
-	if (!keep && (0 == pmb->pmb_refcnt)) {
+	if (!keep && !pmb->pmb_refcnt) {
 		pmemblk_close(pmb->pmb_pool);
 		pmb->pmb_pool = NULL;
 		free(pmb->pmb_filename);
@@ -373,21 +318,15 @@ pmb_close(
 		free(pmb);
 	}
 
-	CACHE_UNLOCK();
-
-}  /* pmb_close() */
-
+	pthread_mutex_unlock(&CacheLock);
+}
 
-static int
-pmb_get_flags(
-	struct thread_data* td,
-	uint64_t*           pflags
-)
+static int pmb_get_flags(struct thread_data *td, uint64_t *pflags)
 {
-	static int thread_warned  = 0;
+	static int thread_warned = 0;
 	static int odirect_warned = 0;
 
-	uint64_t   flags          = 0;
+	uint64_t flags = 0;
 
 	if (!td->o.use_thread) {
 		if (!thread_warned) {
@@ -407,67 +346,49 @@ pmb_get_flags(
 
 	(*pflags) = flags;
 	return 0;
+}
 
-}  /* pmb_get_flags() */
-
-
-static int
-fio_pmemblk_open_file(
-	struct thread_data* td,
-	struct fio_file*    f)
+static int fio_pmemblk_open_file(struct thread_data *td, struct fio_file *f)
 {
-	uint64_t             flags = 0;
-	fio_pmemblk_file_t   pmb;
+	uint64_t flags = 0;
+	fio_pmemblk_file_t pmb;
 
-	if (0 != pmb_get_flags(td, &flags))
+	if (pmb_get_flags(td, &flags))
 		return 1;
 
 	pmb = pmb_open(f->file_name, flags);
-	if (NULL == pmb)
+	if (!pmb)
 		return 1;
 
 	FIOFILEPMBSET(f, pmb);
-
 	return 0;
+}
 
-}  /* fio_pmemblk_open_file() */
-
-
-static int
-fio_pmemblk_close_file(
-	struct thread_data fio_unused* td,
-	struct fio_file*               f
-)
+static int fio_pmemblk_close_file(struct thread_data fio_unused *td,
+				  struct fio_file *f)
 {
-	fio_pmemblk_file_t   pmb = FIOFILEPMBGET(f);
+	fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
 
 	if (pmb)
-		pmb_close(pmb, 0);
+		pmb_close(pmb, false);
 
 	FIOFILEPMBSET(f, NULL);
-
 	return 0;
+}
 
-}  /* fio_pmemblk_close_file() */
-
-
-static int
-fio_pmemblk_get_file_size(
-	struct thread_data* td,
-	struct fio_file*    f
-)
+static int fio_pmemblk_get_file_size(struct thread_data *td, struct fio_file *f)
 {
-	uint64_t             flags = 0;
-	fio_pmemblk_file_t   pmb   = FIOFILEPMBGET(f);
+	uint64_t flags = 0;
+	fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
 
 	if (fio_file_size_known(f))
 		return 0;
 
-	if (NULL == pmb) {
-		if (0 != pmb_get_flags(td, &flags))
+	if (!pmb) {
+		if (pmb_get_flags(td, &flags))
 			return 1;
 		pmb = pmb_open(f->file_name, flags);
-		if (NULL == pmb)
+		if (!pmb)
 			return 1;
 	}
 
@@ -475,26 +396,21 @@ fio_pmemblk_get_file_size(
 
 	fio_file_set_size_known(f);
 
-	if (NULL == FIOFILEPMBGET(f))
-		pmb_close(pmb, 1);
+	if (!FIOFILEPMBGET(f))
+		pmb_close(pmb, true);
 
 	return 0;
+}
 
-}  /* fio_pmemblk_get_file_size() */
-
-
-static int
-fio_pmemblk_queue(
-	struct thread_data* td,
-	struct io_u*        io_u)
+static int fio_pmemblk_queue(struct thread_data *td, struct io_u *io_u)
 {
-	struct fio_file*     f   = io_u->file;
-	fio_pmemblk_file_t   pmb = FIOFILEPMBGET(f);
+	struct fio_file *f = io_u->file;
+	fio_pmemblk_file_t pmb = FIOFILEPMBGET(f);
 
-	unsigned long long   off;
-	unsigned long        len;
-	void*                buf;
-	int (*blkop)(PMEMblkpool*, void*, off_t) = (void*)pmemblk_write;
+	unsigned long long off;
+	unsigned long len;
+	void *buf;
+	int (*blkop) (PMEMblkpool *, void *, off_t) = (void *)pmemblk_write;
 
 	fio_ro_check(td, io_u);
 
@@ -507,9 +423,9 @@ fio_pmemblk_queue(
 		len = io_u->xfer_buflen;
 
 		io_u->error = EINVAL;
-		if (0 != (off % pmb->pmb_bsize))
+		if (off % pmb->pmb_bsize)
 			break;
-		if (0 != (len % pmb->pmb_bsize))
+		if (len % pmb->pmb_bsize)
 			break;
 		if ((off + len) / pmb->pmb_bsize > pmb->pmb_nblocks)
 			break;
@@ -543,19 +459,13 @@ fio_pmemblk_queue(
 	}
 
 	return FIO_Q_COMPLETED;
+}
 
-}  /* fio_pmemblk_queue() */
-
-
-static int
-fio_pmemblk_unlink_file(
-	struct thread_data* td,
-	struct fio_file*    f
-)
+static int fio_pmemblk_unlink_file(struct thread_data *td, struct fio_file *f)
 {
-	char*      path  = NULL;
-	uint64_t   bsize = 0;
-	uint64_t   fsize = 0;
+	char *path = NULL;
+	uint64_t bsize = 0;
+	uint64_t fsize = 0;
 
 	/*
 	 * we need our own unlink in case the user has specified
@@ -564,39 +474,31 @@ fio_pmemblk_unlink_file(
 	 */
 
 	pmb_parse_path(f->file_name, &path, &bsize, &fsize);
-	if (NULL == path)
-		return 1;
+	if (!path)
+		return ENOENT;
 
 	unlink(path);
 	free(path);
-
 	return 0;
-
-}  /* fio_pmemblk_unlink_file() */
-
+}
 
 struct ioengine_ops ioengine = {
-	.name	    	= "pmemblk",
-	.version    	= FIO_IOOPS_VERSION,
-	.queue	    	= fio_pmemblk_queue,
-	.open_file      = fio_pmemblk_open_file,
-	.close_file     = fio_pmemblk_close_file,
-	.get_file_size	= fio_pmemblk_get_file_size,
-	.unlink_file    = fio_pmemblk_unlink_file,
-	.flags	    	= FIO_SYNCIO | FIO_DISKLESSIO | FIO_NOEXTEND | FIO_NODISKUTIL,
+	.name = "pmemblk",
+	.version = FIO_IOOPS_VERSION,
+	.queue = fio_pmemblk_queue,
+	.open_file = fio_pmemblk_open_file,
+	.close_file = fio_pmemblk_close_file,
+	.get_file_size = fio_pmemblk_get_file_size,
+	.unlink_file = fio_pmemblk_unlink_file,
+	.flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_NOEXTEND | FIO_NODISKUTIL,
 };
 
-
-static void
-fio_init fio_pmemblk_register(void)
+static void fio_init fio_pmemblk_register(void)
 {
 	register_ioengine(&ioengine);
 }
 
-
-static void
-fio_exit fio_pmemblk_unregister(void)
+static void fio_exit fio_pmemblk_unregister(void)
 {
 	unregister_ioengine(&ioengine);
 }
-