diff --git a/benchmarks/bench_storage.c b/benchmarks/bench_storage.c
index 2a7042c87..7160b5290 100644
--- a/benchmarks/bench_storage.c
+++ b/benchmarks/bench_storage.c
@@ -5,6 +5,7 @@
 #include <errno.h>
 #include <pthread.h>
 
+#include <datapool/datapool.h>
 #include <bench_storage.h>
 #include <time/cc_timer.h>
 #include <cc_debug.h>
@@ -50,6 +51,7 @@ struct benchmark_specific {
 
 struct benchmark_options {
     struct benchmark_specific benchmark;
+    datapool_options_st datapool;
     struct option engine[]; /* storage-engine specific options... */
 };
 
@@ -73,10 +75,15 @@ benchmark_create(struct benchmark *b, const char *config)
     struct benchmark_specific opts = { BENCHMARK_OPTION(OPTION_INIT) };
     option_load_default((struct option *)&opts, nopts);
 
+    datapool_options_st datapool = { DATAPOOL_OPTION(OPTION_INIT) };
+    option_load_default((struct option *)&(datapool), OPTION_CARDINALITY(datapool_options_st));
+
+    nopts += OPTION_CARDINALITY(datapool_options_st);
     nopts += bench_storage_config_nopts();
 
     b->options = cc_alloc(sizeof(struct option) * nopts);
     b->options->benchmark = opts;
+    b->options->datapool = datapool;
 
     bench_storage_config_init(b->options->engine);
 
diff --git a/src/datapool/datapool.h b/src/datapool/datapool.h
index 10a9fe368..96e735060 100644
--- a/src/datapool/datapool.h
+++ b/src/datapool/datapool.h
@@ -1,14 +1,37 @@
 #pragma once
 
+#include <cc_option.h>
 #include <stddef.h>
 #include <stdbool.h>
+
+#define DATAPOOL_PATH NULL
+#define DATAPOOL_NAME "datapool"
+#define DATAPOOL_PREFAULT false
+
+/*          name                type               default             description */
+#define DATAPOOL_OPTION(ACTION)  \
+    ACTION( datapool_path,      OPTION_TYPE_STR,   DATAPOOL_PATH,      "path to data pool"   )\
+    ACTION( datapool_name,      OPTION_TYPE_STR,   DATAPOOL_NAME,      "datapool name"       )\
+    ACTION( datapool_prefault,  OPTION_TYPE_BOOL,  DATAPOOL_PREFAULT,  "prefault datapool"   )
+
+typedef struct {
+    DATAPOOL_OPTION(OPTION_DECLARE)
+} datapool_options_st;
+
+typedef enum datapool_medium {
+    DATAPOOL_MEDIUM_SHM        = 0,
+    DATAPOOL_MEDIUM_PMEM       = 1
+} datapool_medium_e;
+
 struct datapool;
 
-struct datapool *datapool_open(const char *path, const char *user_signature,
-    size_t size, int *fresh, bool prefault);
+struct datapool *datapool_open(size_t size, int *fresh);
 void datapool_close(struct datapool *pool);
 
 void *datapool_addr(struct datapool *pool);
 size_t datapool_size(struct datapool *pool);
 void datapool_set_user_data(const struct datapool *pool, const void *user_data, size_t user_size);
 void datapool_get_user_data(const struct datapool *pool, void *user_data, size_t user_size);
+datapool_medium_e datapool_get_medium(void);
+void datapool_setup(datapool_options_st *options);
+void datapool_teardown(void);
diff --git a/src/datapool/datapool_pmem.c b/src/datapool/datapool_pmem.c
index c54fe1cd9..8c7332e98 100644
--- a/src/datapool/datapool_pmem.c
+++ b/src/datapool/datapool_pmem.c
@@ -12,6 +12,53 @@
 #include <libpmem.h>
 #include <errno.h>
 
+#define DATAPOOL_MODULE_NAME "datapool::pmem"
+
+static bool datapool_init = false;
+
+static char* datapool_path = DATAPOOL_PATH;
+static char* datapool_name = DATAPOOL_NAME;
+static bool datapool_prefault = DATAPOOL_PREFAULT;
+
+
+datapool_medium_e
+datapool_get_medium(void)
+{
+    if (!datapool_path) {
+        return DATAPOOL_MEDIUM_SHM;
+    }
+    return DATAPOOL_MEDIUM_PMEM;
+}
+
+void
+datapool_setup(datapool_options_st *options)
+{
+    log_info("set up the %s module", DATAPOOL_MODULE_NAME);
+
+    if (datapool_init) {
+        log_warn("datapool has already been setup, re-creating");
+        datapool_teardown();
+    }
+
+    if (options != NULL) {
+        datapool_path = option_str(&options->datapool_path);
+        datapool_name = option_str(&options->datapool_name);
+        datapool_prefault = option_bool(&options->datapool_prefault);
+    }
+    datapool_init = true;
+}
+
+void
+datapool_teardown(void)
+{
+    log_info("tear down the %s module", DATAPOOL_MODULE_NAME);
+
+    if (!datapool_init) {
+        log_warn("%s has never been setup", DATAPOOL_MODULE_NAME);
+    }
+    datapool_init = false;
+}
+
 #define DATAPOOL_SIGNATURE ("PELIKAN") /* 8 bytes */
 #define DATAPOOL_SIGNATURE_LEN (sizeof(DATAPOOL_SIGNATURE))
 
@@ -72,9 +119,9 @@ datapool_sync(struct datapool *pool)
 }
 
 static bool
-datapool_valid_user_signature(struct datapool *pool, const char *user_name)
+datapool_valid_user_signature(struct datapool *pool)
 {
-    if (cc_strcmp(pool->hdr->user_signature, user_name)) {
+    if (cc_strcmp(pool->hdr->user_signature, datapool_name)) {
         return false;
     }
     return true;
@@ -120,7 +167,7 @@ datapool_valid(struct datapool *pool)
 }
 
 static void
-datapool_initialize(struct datapool *pool, const char *user_name)
+datapool_initialize(struct datapool *pool)
 {
     log_info("initializing fresh datapool");
 
@@ -132,7 +179,7 @@ datapool_initialize(struct datapool *pool, const char *user_name)
     pool->hdr->version = DATAPOOL_VERSION;
     pool->hdr->size = pool->mapped_len;
     pool->hdr->flags = 0;
-    cc_memcpy(pool->hdr->user_signature, user_name, cc_strlen(user_name));
+    cc_memcpy(pool->hdr->user_signature, datapool_name, cc_strlen(datapool_name));
     datapool_sync_hdr(pool);
 
     /* 3. set the signature */
@@ -163,7 +210,7 @@ datapool_flag_clear(struct datapool *pool, int flag)
  * finish successfully.
  */
 struct datapool *
-datapool_open(const char *path, const char *user_signature, size_t size, int *fresh, bool prefault)
+datapool_open(size_t size, int *fresh)
 {
     struct datapool *pool = cc_alloc(sizeof(*pool));
     if (pool == NULL) {
@@ -171,35 +218,35 @@ datapool_open(const char *path, const char *user_signature, size_t size, int *fr
         goto err_alloc;
     }
 
-    if (user_signature == NULL) {
+    if (datapool_name == NULL) {
         log_error("empty user signature");
         goto err_map;
     }
 
-    if (cc_strnlen(user_signature, DATAPOOL_USER_LAYOUT_LEN) == DATAPOOL_USER_LAYOUT_LEN ) {
-        log_error("user signature is too long %zu", cc_strlen(user_signature));
+    if (cc_strnlen(datapool_name, DATAPOOL_USER_LAYOUT_LEN) == DATAPOOL_USER_LAYOUT_LEN ) {
+        log_error("user signature is too long %zu", cc_strlen(datapool_name));
         goto err_map;
     }
 
     size_t map_size = size + sizeof(struct datapool_header);
 
-    if (path == NULL) { /* fallback to DRAM if pmem is not configured */
+    if (datapool_path == NULL) { /* fallback to DRAM if pmem is not configured */
         pool->addr = cc_zalloc(map_size);
         pool->mapped_len = map_size;
         pool->is_pmem = 0;
         pool->file_backed = 0;
     } else {
-        pool->addr = pmem_map_file(path, map_size, PMEM_FILE_CREATE, 0600,
+        pool->addr = pmem_map_file(datapool_path, map_size, PMEM_FILE_CREATE, 0600,
             &pool->mapped_len, &pool->is_pmem);
         pool->file_backed = 1;
     }
 
     if (pool->addr == NULL) {
-        log_error(path == NULL ? strerror(errno) : pmem_errormsg());
+        log_error(datapool_path == NULL ? strerror(errno) : pmem_errormsg());
         goto err_map;
     }
 
-    if (prefault) {
+    if (datapool_prefault) {
         log_info("prefault datapool");
         volatile char *cur_addr = pool->addr;
         char *addr_end = (char *)cur_addr + map_size;
@@ -209,7 +256,7 @@ datapool_open(const char *path, const char *user_signature, size_t size, int *fr
     }
 
     log_info("mapped datapool %s with size %llu, is_pmem: %d",
-        path, pool->mapped_len, pool->is_pmem);
+        datapool_path, pool->mapped_len, pool->is_pmem);
 
     pool->hdr = pool->addr;
     pool->user_addr = (uint8_t *)pool->addr + sizeof(struct datapool_header);
@@ -223,9 +270,9 @@ datapool_open(const char *path, const char *user_signature, size_t size, int *fr
             *fresh = 1;
         }
 
-        datapool_initialize(pool, user_signature);
-    } else if (!datapool_valid_user_signature(pool, user_signature)) {
-        log_error("wrong user signature (%s) used for pool", user_signature);
+        datapool_initialize(pool);
+    } else if (!datapool_valid_user_signature(pool)) {
+        log_error("wrong user signature (%s) used for pool", datapool_name);
         goto err_map_adr;
     }
 
diff --git a/src/datapool/datapool_shm.c b/src/datapool/datapool_shm.c
index 4c0f01d0a..f860f5d06 100644
--- a/src/datapool/datapool_shm.c
+++ b/src/datapool/datapool_shm.c
@@ -7,10 +7,50 @@
 #include <cc_debug.h>
 #include <cc_mm.h>
 
+#define DATAPOOL_MODULE_NAME "datapool::shm"
+
+static bool datapool_init = false;
+
+static char* datapool_path = DATAPOOL_PATH;
+
+datapool_medium_e
+datapool_get_medium(void)
+{
+    return DATAPOOL_MEDIUM_SHM;
+}
+
+void
+datapool_setup(datapool_options_st *options)
+{
+    log_info("set up the %s module", DATAPOOL_MODULE_NAME);
+
+    if (datapool_init) {
+        log_warn("datapool has already been setup, re-creating");
+        datapool_teardown();
+    }
+
+    if (options != NULL) {
+        datapool_path = option_str(&options->datapool_path);
+    }
+    datapool_init = true;
+}
+
+void
+datapool_teardown(void)
+{
+    log_info("tear down the %s module", DATAPOOL_MODULE_NAME);
+
+    if (!datapool_init) {
+        log_warn("%s has never been setup", DATAPOOL_MODULE_NAME);
+    }
+
+    datapool_init = false;
+}
+
 struct datapool *
-datapool_open(const char *path, const char *user_signature, size_t size, int *fresh, bool prefault)
+datapool_open(size_t size, int *fresh)
 {
-    if (path != NULL) {
+    if (datapool_path != NULL) {
         log_warn("attempted to open a file-based data pool without"
             "pmem features enabled");
         return NULL;
diff --git a/src/server/ds/main.c b/src/server/ds/main.c
index ada1a0594..3320182f0 100644
--- a/src/server/ds/main.c
+++ b/src/server/ds/main.c
@@ -55,6 +55,7 @@ teardown(void)
     admin_process_teardown();
     process_teardown();
     slab_teardown();
+    datapool_teardown();
     compose_teardown();
     parse_teardown();
     response_teardown();
@@ -116,6 +117,7 @@ setup(void)
     response_setup(&setting.response, &stats.response);
     parse_setup(&stats.parse_req, NULL);
     compose_setup(NULL, &stats.compose_rsp);
+    datapool_setup(&setting.datapool);
     slab_setup(&setting.slab, &stats.slab);
     process_setup(&setting.process, &stats.process);
     admin_process_setup();
diff --git a/src/server/ds/setting.c b/src/server/ds/setting.c
index 1ef57d1e9..ca13b7667 100644
--- a/src/server/ds/setting.c
+++ b/src/server/ds/setting.c
@@ -8,6 +8,7 @@ struct setting setting = {
     { PROCESS_OPTION(OPTION_INIT)   },
     { REQUEST_OPTION(OPTION_INIT)   },
     { RESPONSE_OPTION(OPTION_INIT)  },
+    { DATAPOOL_OPTION(OPTION_INIT)  },
     { SLAB_OPTION(OPTION_INIT)      },
     { TIME_OPTION(OPTION_INIT)      },
     { ARRAY_OPTION(OPTION_INIT)     },
diff --git a/src/server/ds/setting.h b/src/server/ds/setting.h
index 46a44c210..d48867649 100644
--- a/src/server/ds/setting.h
+++ b/src/server/ds/setting.h
@@ -3,6 +3,7 @@
 #include "data/process.h"
 
 #include "core/core.h"
+#include "datapool/datapool.h"
 #include "storage/slab/item.h"
 #include "storage/slab/slab.h"
 #include "protocol/data/redis_include.h"
@@ -37,6 +38,7 @@ struct setting {
     process_options_st  process;
     request_options_st  request;
     response_options_st response;
+    datapool_options_st datapool;
     slab_options_st     slab;
     time_options_st     time;
     /* ccommon libraries */
diff --git a/src/server/slimcache/main.c b/src/server/slimcache/main.c
index 5a73f8898..4dc7371af 100644
--- a/src/server/slimcache/main.c
+++ b/src/server/slimcache/main.c
@@ -60,6 +60,7 @@ teardown(void)
     admin_process_teardown();
     process_teardown();
     cuckoo_teardown();
+    datapool_teardown();
     klog_teardown();
     compose_teardown();
     parse_teardown();
diff --git a/src/server/slimcache/setting.c b/src/server/slimcache/setting.c
index 13cd55cde..21d954d34 100644
--- a/src/server/slimcache/setting.c
+++ b/src/server/slimcache/setting.c
@@ -9,6 +9,7 @@ struct setting setting = {
     { KLOG_OPTION(OPTION_INIT)      },
     { REQUEST_OPTION(OPTION_INIT)   },
     { RESPONSE_OPTION(OPTION_INIT)  },
+    { DATAPOOL_OPTION(OPTION_INIT)  },
     { CUCKOO_OPTION(OPTION_INIT)    },
     { TIME_OPTION(OPTION_INIT)      },
     { ARRAY_OPTION(OPTION_INIT)     },
diff --git a/src/server/slimcache/setting.h b/src/server/slimcache/setting.h
index 5b553a41e..8499ce5a3 100644
--- a/src/server/slimcache/setting.h
+++ b/src/server/slimcache/setting.h
@@ -4,6 +4,7 @@
 #include "data/process.h"
 
 #include "core/core.h"
+#include "datapool/datapool.h"
 #include "storage/cuckoo/cuckoo.h"
 #include "protocol/data/memcache_include.h"
 #include "time/time.h"
@@ -41,6 +42,7 @@ struct setting {
     klog_options_st         klog;
     request_options_st      request;
     response_options_st     response;
+    datapool_options_st     datapool;
     cuckoo_options_st       cuckoo;
     time_options_st         time;
     /* ccommon libraries */
diff --git a/src/server/slimds/main.c b/src/server/slimds/main.c
index a85ed9786..3eab01a82 100644
--- a/src/server/slimds/main.c
+++ b/src/server/slimds/main.c
@@ -59,6 +59,7 @@ teardown(void)
     response_teardown();
     request_teardown();
     cuckoo_teardown();
+    datapool_teardown();
     procinfo_teardown();
     time_teardown();
 
diff --git a/src/server/slimds/setting.c b/src/server/slimds/setting.c
index 07502c20a..2936cd7e3 100644
--- a/src/server/slimds/setting.c
+++ b/src/server/slimds/setting.c
@@ -8,6 +8,7 @@ struct setting setting = {
     { PROCESS_OPTION(OPTION_INIT)   },
     { REQUEST_OPTION(OPTION_INIT)   },
     { RESPONSE_OPTION(OPTION_INIT)  },
+    { DATAPOOL_OPTION(OPTION_INIT)  },
     { CUCKOO_OPTION(OPTION_INIT)    },
     { TIME_OPTION(OPTION_INIT)      },
     { ARRAY_OPTION(OPTION_INIT)     },
diff --git a/src/server/slimds/setting.h b/src/server/slimds/setting.h
index c0da49043..d1e4ce3a6 100644
--- a/src/server/slimds/setting.h
+++ b/src/server/slimds/setting.h
@@ -3,6 +3,7 @@
 #include "data/process.h"
 
 #include "core/core.h"
+#include "datapool/datapool.h"
 #include "storage/cuckoo/cuckoo.h"
 #include "protocol/data/redis_include.h"
 #include "time/time.h"
@@ -36,6 +37,7 @@ struct setting {
     process_options_st  process;
     request_options_st  request;
     response_options_st response;
+    datapool_options_st datapool;
     cuckoo_options_st   cuckoo;
     time_options_st     time;
     /* ccommon libraries */
diff --git a/src/server/twemcache/main.c b/src/server/twemcache/main.c
index 773cfd43b..8b98b3e55 100644
--- a/src/server/twemcache/main.c
+++ b/src/server/twemcache/main.c
@@ -56,6 +56,7 @@ teardown(void)
     admin_process_teardown();
     process_teardown();
     slab_teardown();
+    datapool_teardown();
     klog_teardown();
     compose_teardown();
     parse_teardown();
@@ -121,6 +122,7 @@ setup(void)
     parse_setup(&stats.parse_req, NULL);
     compose_setup(NULL, &stats.compose_rsp);
     klog_setup(&setting.klog, &stats.klog);
+    datapool_setup(&setting.datapool);
     slab_setup(&setting.slab, &stats.slab);
     process_setup(&setting.process, &stats.process);
     admin_process_setup();
diff --git a/src/server/twemcache/setting.c b/src/server/twemcache/setting.c
index 95e3cc297..8c9c89aea 100644
--- a/src/server/twemcache/setting.c
+++ b/src/server/twemcache/setting.c
@@ -9,6 +9,7 @@ struct setting setting = {
     { KLOG_OPTION(OPTION_INIT)      },
     { REQUEST_OPTION(OPTION_INIT)   },
     { RESPONSE_OPTION(OPTION_INIT)  },
+    { DATAPOOL_OPTION(OPTION_INIT)  },
     { SLAB_OPTION(OPTION_INIT)      },
     { TIME_OPTION(OPTION_INIT)      },
     { ARRAY_OPTION(OPTION_INIT)     },
diff --git a/src/server/twemcache/setting.h b/src/server/twemcache/setting.h
index d57f20521..f9c5d9224 100644
--- a/src/server/twemcache/setting.h
+++ b/src/server/twemcache/setting.h
@@ -3,6 +3,7 @@
 #include "data/process.h"
 
 #include "core/core.h"
+#include "datapool/datapool.h"
 #include "protocol/data/memcache_include.h"
 #include "storage/slab/item.h"
 #include "storage/slab/slab.h"
@@ -41,6 +42,7 @@ struct setting {
     klog_options_st         klog;
     request_options_st      request;
     response_options_st     response;
+    datapool_options_st     datapool;
     slab_options_st         slab;
     time_options_st         time;
     /* ccommon libraries */
diff --git a/src/storage/cuckoo/cuckoo.c b/src/storage/cuckoo/cuckoo.c
index 1a8956cbf..67f69d86f 100644
--- a/src/storage/cuckoo/cuckoo.c
+++ b/src/storage/cuckoo/cuckoo.c
@@ -286,9 +286,7 @@ cuckoo_setup(cuckoo_options_st *options, cuckoo_metrics_st *metrics)
     }
 
     hash_size = item_size * max_nitem;
-    pool = datapool_open(option_str(&options->cuckoo_datapool),
-        option_str(&options->cuckoo_datapool_name), hash_size,
-        NULL, option_bool(&options->cuckoo_datapool_prefault));
+    pool = datapool_open(hash_size, NULL);
     if (pool == NULL) {
         log_crit("cuckoo data store allocation failed");
         exit(EX_CONFIG);
diff --git a/src/storage/cuckoo/cuckoo.h b/src/storage/cuckoo/cuckoo.h
index 1cc7cbcdd..a9a2cecf7 100644
--- a/src/storage/cuckoo/cuckoo.h
+++ b/src/storage/cuckoo/cuckoo.h
@@ -17,22 +17,15 @@
 #define CUCKOO_NITEM 1024
 #define CUCKOO_POLICY CUCKOO_POLICY_RANDOM
 #define CUCKOO_MAX_TTL (30 * 24 * 60 * 60) /* 30 days */
-#define CUCKOO_DATAPOOL NULL
-#define CUCKOO_DATAPOOL_NAME "cuckoo_datapool"
-#define CUCKOO_PREFAULT false
-
-/*          name                      type                default                  description */
-#define CUCKOO_OPTION(ACTION)                                                                          \
-    ACTION( cuckoo_displace,          OPTION_TYPE_UINT,   CUCKOO_DISPLACE,         "# displaces allowed"   )\
-    ACTION( cuckoo_item_cas,          OPTION_TYPE_BOOL,   CUCKOO_ITEM_CAS,         "support cas in items"  )\
-    ACTION( cuckoo_item_size,         OPTION_TYPE_UINT,   CUCKOO_ITEM_SIZE,        "item size (inclusive)" )\
-    ACTION( cuckoo_nitem,             OPTION_TYPE_UINT,   CUCKOO_NITEM,            "# items allocated"     )\
-    ACTION( cuckoo_policy,            OPTION_TYPE_UINT,   CUCKOO_POLICY,           "evict policy"          )\
-    ACTION( cuckoo_max_ttl,           OPTION_TYPE_UINT,   CUCKOO_MAX_TTL,          "max ttl in seconds"    )\
-    ACTION( cuckoo_datapool,          OPTION_TYPE_STR,    CUCKOO_DATAPOOL,         "path to data pool"     )\
-    ACTION( cuckoo_datapool_name,     OPTION_TYPE_STR,    CUCKOO_DATAPOOL_NAME,    "cuckoo datapool name"  )\
-    ACTION( cuckoo_datapool_prefault, OPTION_TYPE_BOOL,   CUCKOO_PREFAULT,         "prefault data pool"    )
 
+/*          name                type                default             description */
+#define CUCKOO_OPTION(ACTION)                                                                    \
+    ACTION( cuckoo_displace,    OPTION_TYPE_UINT,   CUCKOO_DISPLACE,    "# displaces allowed"   )\
+    ACTION( cuckoo_item_cas,    OPTION_TYPE_BOOL,   CUCKOO_ITEM_CAS,    "support cas in items"  )\
+    ACTION( cuckoo_item_size,   OPTION_TYPE_UINT,   CUCKOO_ITEM_SIZE,   "item size (inclusive)" )\
+    ACTION( cuckoo_nitem,       OPTION_TYPE_UINT,   CUCKOO_NITEM,       "# items allocated"     )\
+    ACTION( cuckoo_policy,      OPTION_TYPE_UINT,   CUCKOO_POLICY,      "evict policy"          )\
+    ACTION( cuckoo_max_ttl,     OPTION_TYPE_UINT,   CUCKOO_MAX_TTL,     "max ttl in seconds"    )
 
 typedef struct {
     CUCKOO_OPTION(OPTION_DECLARE)
diff --git a/src/storage/slab/slab.c b/src/storage/slab/slab.c
index f2030dcba..45193b873 100644
--- a/src/storage/slab/slab.c
+++ b/src/storage/slab/slab.c
@@ -48,9 +48,6 @@ static size_t item_min = ITEM_SIZE_MIN; /* min item size */
 static size_t item_max = ITEM_SIZE_MAX; /* max item size */
 static double item_growth = ITEM_FACTOR;/* item size growth factor */
 static uint32_t hash_power = HASH_POWER;/* power (of 2) entries for hashtable */
-static char *slab_datapool = SLAB_DATAPOOL;   /* slab datapool path */
-static bool prefault = SLAB_PREFAULT;         /* slab datapool prefault option */
-static char *slab_datapool_name = SLAB_DATAPOOL_NAME;   /* slab datapool name */
 
 bool use_cas = SLAB_USE_CAS;
 struct hash_table *hash_table = NULL;
@@ -323,8 +320,7 @@ _slab_heapinfo_setup(void)
 
     heapinfo.base = NULL;
     if (prealloc) {
-        pool_slab = datapool_open(slab_datapool, slab_datapool_name,
-                 heapinfo.max_nslab * slab_size, &pool_slab_state, prefault);
+        pool_slab = datapool_open(heapinfo.max_nslab * slab_size, &pool_slab_state);
         if (pool_slab == NULL) {
             log_crit("Could not create pool_slab");
             exit(EX_CONFIG);
@@ -339,7 +335,7 @@ _slab_heapinfo_setup(void)
 
         log_info("pre-allocated %zu bytes for %"PRIu32" slabs",
                   slab_mem, heapinfo.max_nslab);
-    } else if (slab_datapool) {
+     } else if (datapool_get_medium() == DATAPOOL_MEDIUM_PMEM) {
         log_error("PMEM is supported only for prealloc option");
         return CC_EINVAL;
     }
@@ -572,9 +568,6 @@ slab_setup(slab_options_st *options, slab_metrics_st *metrics)
         max_ttl = option_uint(&options->slab_item_max_ttl);
         use_cas = option_bool(&options->slab_use_cas);
         hash_power = option_uint(&options->slab_hash_power);
-        slab_datapool = option_str(&options->slab_datapool);
-        slab_datapool_name = option_str(&options->slab_datapool_name);
-        prefault = option_bool(&options->slab_datapool_prefault);
     }
 
     hash_table = hashtable_create(hash_power);
diff --git a/src/storage/slab/slab.h b/src/storage/slab/slab.h
index b344f787f..8dfb6f62d 100644
--- a/src/storage/slab/slab.h
+++ b/src/storage/slab/slab.h
@@ -29,9 +29,6 @@
 #define ITEM_FACTOR     1.25
 #define ITEM_MAX_TTL    (30 * 24 * 60 * 60) /* 30 days */
 #define HASH_POWER      16
-#define SLAB_DATAPOOL   NULL
-#define SLAB_PREFAULT   false
-#define SLAB_DATAPOOL_NAME "slab_datapool"
 
 /* Eviction options */
 #define EVICT_NONE    0 /* throw OOM, no eviction */
@@ -41,24 +38,20 @@
 
 /* The defaults here are placeholder values for now */
 /* TODO: consider moving item options to item.[h|c] */
-/*          name                    type                default              description */
-#define SLAB_OPTION(ACTION)                                                                                   \
-    ACTION( slab_size,              OPTION_TYPE_UINT,   SLAB_SIZE,           "Slab size"                     )\
-    ACTION( slab_mem,               OPTION_TYPE_UINT,   SLAB_MEM,            "Max memory by slabs (byte)"    )\
-    ACTION( slab_prealloc,          OPTION_TYPE_BOOL,   SLAB_PREALLOC,       "Pre-allocate slabs at setup"   )\
-    ACTION( slab_evict_opt,         OPTION_TYPE_UINT,   SLAB_EVICT_OPT,      "Eviction strategy"             )\
-    ACTION( slab_use_freeq,         OPTION_TYPE_BOOL,   SLAB_USE_FREEQ,      "Use items in free queue?"      )\
-    ACTION( slab_profile,           OPTION_TYPE_STR,    SLAB_PROFILE,        "Specify entire slab profile"   )\
-    ACTION( slab_item_min,          OPTION_TYPE_UINT,   ITEM_SIZE_MIN,       "Minimum item size"             )\
-    ACTION( slab_item_max,          OPTION_TYPE_UINT,   ITEM_SIZE_MAX,       "Maximum item size"             )\
-    ACTION( slab_item_growth,       OPTION_TYPE_FPN,    ITEM_FACTOR,         "Slab class growth factor"      )\
-    ACTION( slab_item_max_ttl,      OPTION_TYPE_UINT,   ITEM_MAX_TTL,        "Max ttl in seconds"            )\
-    ACTION( slab_use_cas,           OPTION_TYPE_BOOL,   SLAB_USE_CAS,        "Store CAS value in item"       )\
-    ACTION( slab_hash_power,        OPTION_TYPE_UINT,   HASH_POWER,          "Power for lookup hash table"   )\
-    ACTION( slab_datapool,          OPTION_TYPE_STR,    SLAB_DATAPOOL,       "Path to data pool"             )\
-    ACTION( slab_datapool_name,     OPTION_TYPE_STR,    SLAB_DATAPOOL_NAME,  "Slab data pool name"           )\
-    ACTION( slab_datapool_prefault, OPTION_TYPE_BOOL,   SLAB_PREFAULT,       "Prefault data pool"            )
-
+/*          name                type                default         description */
+#define SLAB_OPTION(ACTION)                                                                          \
+    ACTION( slab_size,          OPTION_TYPE_UINT,   SLAB_SIZE,      "Slab size"                     )\
+    ACTION( slab_mem,           OPTION_TYPE_UINT,   SLAB_MEM,       "Max memory by slabs (byte)"    )\
+    ACTION( slab_prealloc,      OPTION_TYPE_BOOL,   SLAB_PREALLOC,  "Pre-allocate slabs at setup"   )\
+    ACTION( slab_evict_opt,     OPTION_TYPE_UINT,   SLAB_EVICT_OPT, "Eviction strategy"             )\
+    ACTION( slab_use_freeq,     OPTION_TYPE_BOOL,   SLAB_USE_FREEQ, "Use items in free queue?"      )\
+    ACTION( slab_profile,       OPTION_TYPE_STR,    SLAB_PROFILE,   "Specify entire slab profile"   )\
+    ACTION( slab_item_min,      OPTION_TYPE_UINT,   ITEM_SIZE_MIN,  "Minimum item size"             )\
+    ACTION( slab_item_max,      OPTION_TYPE_UINT,   ITEM_SIZE_MAX,  "Maximum item size"             )\
+    ACTION( slab_item_growth,   OPTION_TYPE_FPN,    ITEM_FACTOR,    "Slab class growth factor"      )\
+    ACTION( slab_item_max_ttl,  OPTION_TYPE_UINT,   ITEM_MAX_TTL,   "Max ttl in seconds"            )\
+    ACTION( slab_use_cas,       OPTION_TYPE_BOOL,   SLAB_USE_CAS,   "Store CAS value in item"       )\
+    ACTION( slab_hash_power,    OPTION_TYPE_UINT,   HASH_POWER,     "Power for lookup hash table"   )
 
 typedef struct {
     SLAB_OPTION(OPTION_DECLARE)
@@ -150,6 +143,7 @@ extern slab_metrics_st *slab_metrics;
 extern cc_declare_itt_function(slab_malloc);
 extern cc_declare_itt_function(slab_free);
 
+
 /*
  * Return the usable space for item sized chunks that would be carved out
  * of a given slab.
diff --git a/test/datapool/check_datapool.c b/test/datapool/check_datapool.c
index 8f7d8203c..cfef14aac 100644
--- a/test/datapool/check_datapool.c
+++ b/test/datapool/check_datapool.c
@@ -10,12 +10,27 @@
 #define SUITE_NAME "datapool"
 #define DEBUG_LOG  SUITE_NAME ".log"
 #define TEST_DATAFILE "./datapool.pelikan"
+#define TEST_DATA_NAME "datapool_test"
 #define TEST_DATASIZE (1 << 20)
-#define TEST_DATA_NAME "datapool_pelikan"
+
+datapool_options_st options = { DATAPOOL_OPTION(OPTION_INIT) };
+
+/*
+ * utilities
+ */
+static void
+test_setup(const char *path, const char*name, bool prefault)
+{
+    options.datapool_path.val.vstr = path;
+    options.datapool_name.val.vstr = name;
+    options.datapool_prefault.val.vbool = prefault;
+    datapool_setup(&options);
+}
 
 static void
 test_teardown(const char* str)
 {
+    datapool_teardown();
     unlink(str);
 }
 
@@ -24,8 +39,9 @@ test_teardown(const char* str)
  */
 START_TEST(test_datapool)
 {
+    test_setup(TEST_DATAFILE, TEST_DATA_NAME, false);
     int fresh = 0;
-    struct datapool *pool = datapool_open(TEST_DATAFILE, TEST_DATA_NAME, TEST_DATASIZE, &fresh, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, &fresh);
     ck_assert_ptr_nonnull(pool);
     size_t s = datapool_size(pool);
     ck_assert_int_ge(s, TEST_DATASIZE);
@@ -33,7 +49,7 @@ START_TEST(test_datapool)
     ck_assert_ptr_nonnull(datapool_addr(pool));
     datapool_close(pool);
 
-    pool = datapool_open(TEST_DATAFILE, TEST_DATA_NAME, TEST_DATASIZE, &fresh, false);
+    pool = datapool_open(TEST_DATASIZE, &fresh);
     ck_assert_ptr_nonnull(pool);
     ck_assert_int_eq(s, datapool_size(pool));
     ck_assert_int_eq(fresh, 0);
@@ -44,8 +60,9 @@ END_TEST
 
 START_TEST(test_devzero)
 {
+    test_setup(NULL, TEST_DATA_NAME, false);
     int fresh = 0;
-    struct datapool *pool = datapool_open(NULL, TEST_DATA_NAME, TEST_DATASIZE, &fresh, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, &fresh);
     ck_assert_ptr_nonnull(pool);
     size_t s = datapool_size(pool);
     ck_assert_int_ge(s, TEST_DATASIZE);
@@ -53,12 +70,12 @@ START_TEST(test_devzero)
     ck_assert_ptr_nonnull(datapool_addr(pool));
     datapool_close(pool);
 
-    pool = datapool_open(NULL, TEST_DATA_NAME, TEST_DATASIZE, &fresh, false);
+    pool = datapool_open(TEST_DATASIZE, &fresh);
     ck_assert_ptr_nonnull(pool);
     ck_assert_int_eq(s, datapool_size(pool));
     ck_assert_int_eq(fresh, 1);
     datapool_close(pool);
-    test_teardown(TEST_DATAFILE);
+    datapool_teardown();
 }
 END_TEST
 
@@ -67,14 +84,14 @@ START_TEST(test_datapool_userdata)
 #define MAX_USER_DATA_SIZE 2000
     char data_set[MAX_USER_DATA_SIZE] = {0};
     char data_get[MAX_USER_DATA_SIZE] = {0};
-
-    struct datapool *pool = datapool_open(TEST_DATAFILE, TEST_DATA_NAME, TEST_DATASIZE, NULL, false);
+    test_setup(TEST_DATAFILE, TEST_DATA_NAME, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_nonnull(pool);
     cc_memset(data_set, 'A', MAX_USER_DATA_SIZE);
     datapool_set_user_data(pool, data_set, MAX_USER_DATA_SIZE);
     datapool_close(pool);
 
-    pool = datapool_open(TEST_DATAFILE, TEST_DATA_NAME, TEST_DATASIZE, NULL, false);
+    pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_nonnull(pool);
     datapool_get_user_data(pool, data_get, MAX_USER_DATA_SIZE);
     ck_assert_mem_eq(data_set, data_get, MAX_USER_DATA_SIZE);
@@ -87,7 +104,8 @@ END_TEST
 
 START_TEST(test_datapool_prealloc)
 {
-    struct datapool *pool = datapool_open(TEST_DATAFILE, TEST_DATA_NAME, TEST_DATASIZE, NULL, true);
+    test_setup(TEST_DATAFILE, TEST_DATA_NAME, true);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_nonnull(pool);
     datapool_close(pool);
     test_teardown(TEST_DATAFILE);
@@ -96,16 +114,20 @@ END_TEST
 
 START_TEST(test_datapool_empty_signature)
 {
-    struct datapool *pool = datapool_open(TEST_DATAFILE, NULL, TEST_DATASIZE, NULL, false);
+    test_setup(TEST_DATAFILE, NULL, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_null(pool);
+    datapool_teardown();
 }
 END_TEST
 
 START_TEST(test_datapool_too_long_signature)
 {
 #define LONG_SIGNATURE "Lorem ipsum dolor sit amet, consectetur volutpat"
-    struct datapool *pool = datapool_open(TEST_DATAFILE, LONG_SIGNATURE, TEST_DATASIZE, NULL, false);
+    test_setup(TEST_DATAFILE, LONG_SIGNATURE, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_null(pool);
+    datapool_teardown();
 #undef LONG_SIGNATURE
 }
 END_TEST
@@ -113,7 +135,8 @@ END_TEST
 START_TEST(test_datapool_max_length_signature)
 {
 #define MAX_SIGNATURE "Lorem ipsum dolor sit amet, consectetur volutpa"
-    struct datapool *pool = datapool_open(TEST_DATAFILE, MAX_SIGNATURE, TEST_DATASIZE, NULL, false);
+    test_setup(TEST_DATAFILE, MAX_SIGNATURE, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_nonnull(pool);
     datapool_close(pool);
     test_teardown(TEST_DATAFILE);
@@ -125,15 +148,18 @@ START_TEST(test_datapool_wrong_signature_long_variant)
 {
 #define WRONG_POOL_NAME_LONG_VAR "datapool_pelikan_no_exist"
     int fresh = 0;
-    struct datapool *pool = datapool_open(TEST_DATAFILE, TEST_DATA_NAME, TEST_DATASIZE, &fresh, false);
+    test_setup(TEST_DATAFILE, TEST_DATA_NAME, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, &fresh);
     ck_assert_ptr_nonnull(pool);
     size_t s = datapool_size(pool);
     ck_assert_int_ge(s, TEST_DATASIZE);
     ck_assert_int_eq(fresh, 1);
     ck_assert_ptr_nonnull(datapool_addr(pool));
     datapool_close(pool);
+    datapool_teardown();
 
-    pool = datapool_open(TEST_DATAFILE, WRONG_POOL_NAME_LONG_VAR, TEST_DATASIZE, NULL, false);
+    test_setup(TEST_DATAFILE, WRONG_POOL_NAME_LONG_VAR, false);
+    pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_null(pool);
     test_teardown(TEST_DATAFILE);
 #undef WRONG_POOL_NAME_LONG_VAR
@@ -144,15 +170,18 @@ START_TEST(test_datapool_wrong_signature_short_variant)
 {
 #define WRONG_POOL_NAME_SHORT_VAR "datapool"
     int fresh = 0;
-    struct datapool *pool = datapool_open(TEST_DATAFILE, TEST_DATA_NAME, TEST_DATASIZE, &fresh, false);
+    test_setup(TEST_DATAFILE, TEST_DATA_NAME, false);
+    struct datapool *pool = datapool_open(TEST_DATASIZE, &fresh);
     ck_assert_ptr_nonnull(pool);
     size_t s = datapool_size(pool);
     ck_assert_int_ge(s, TEST_DATASIZE);
     ck_assert_int_eq(fresh, 1);
     ck_assert_ptr_nonnull(datapool_addr(pool));
     datapool_close(pool);
+    datapool_teardown();
 
-    pool = datapool_open(TEST_DATAFILE, WRONG_POOL_NAME_SHORT_VAR, TEST_DATASIZE, NULL, false);
+    test_setup(TEST_DATAFILE, WRONG_POOL_NAME_SHORT_VAR, false);
+    pool = datapool_open(TEST_DATASIZE, NULL);
     ck_assert_ptr_null(pool);
     test_teardown(TEST_DATAFILE);
 #undef WRONG_POOL_NAME_SHORT_VAR
diff --git a/test/storage/cuckoo_pmem/check_cuckoo_pmem.c b/test/storage/cuckoo_pmem/check_cuckoo_pmem.c
index c1c93117a..41f91e66f 100644
--- a/test/storage/cuckoo_pmem/check_cuckoo_pmem.c
+++ b/test/storage/cuckoo_pmem/check_cuckoo_pmem.c
@@ -1,3 +1,4 @@
+#include <datapool/datapool.h>
 #include <storage/cuckoo/item.h>
 #include <storage/cuckoo/cuckoo.h>
 
@@ -13,7 +14,7 @@
 /* define for each suite, local scope due to macro visibility rule */
 #define SUITE_NAME "cuckoo_pmem"
 #define DEBUG_LOG  SUITE_NAME ".log"
-#define DATAPOOL_PATH "./datapool.pelikan"
+#define CUCKOO_DATAPOOL_PATH "./datapool.pelikan"
 
 void test_insert_basic(uint32_t policy, bool cas);
 void test_insert_collision(uint32_t policy, bool cas);
@@ -22,6 +23,7 @@ void test_delete_basic(uint32_t policy, bool cas);
 void test_expire_basic(uint32_t policy, bool cas);
 void test_expire_truncated(uint32_t policy, bool cas);
 
+datapool_options_st datapool_options = { DATAPOOL_OPTION(OPTION_INIT) };
 cuckoo_options_st options = { CUCKOO_OPTION(OPTION_INIT) };
 cuckoo_metrics_st metrics = { CUCKOO_METRIC(METRIC_INIT) };
 
@@ -32,11 +34,12 @@ static void
 test_setup(uint32_t policy, bool cas, delta_time_i ttl)
 {
     option_load_default((struct option *)&options, OPTION_CARDINALITY(options));
+    option_load_default((struct option *)&datapool_options, OPTION_CARDINALITY(datapool_options));
     options.cuckoo_policy.val.vuint = policy;
     options.cuckoo_item_cas.val.vbool = cas;
     options.cuckoo_max_ttl.val.vuint = ttl;
-    options.cuckoo_datapool.val.vstr = DATAPOOL_PATH;
-
+    datapool_options.datapool_path.val.vstr = CUCKOO_DATAPOOL_PATH;
+    datapool_setup(&datapool_options);
     cuckoo_setup(&options, &metrics);
 }
 
@@ -44,8 +47,9 @@ static void
 test_teardown(int un)
 {
     cuckoo_teardown();
+    datapool_teardown();
     if (un)
-        unlink(DATAPOOL_PATH);
+        unlink(CUCKOO_DATAPOOL_PATH);
 }
 
 static void
diff --git a/test/storage/slab_pmem/check_slab_pmem.c b/test/storage/slab_pmem/check_slab_pmem.c
index c4f719a0d..c3de6ef73 100644
--- a/test/storage/slab_pmem/check_slab_pmem.c
+++ b/test/storage/slab_pmem/check_slab_pmem.c
@@ -1,3 +1,4 @@
+#include <datapool/datapool.h>
 #include <storage/slab/item.h>
 #include <storage/slab/slab.h>
 
@@ -13,8 +14,10 @@
 /* define for each suite, local scope due to macro visibility rule */
 #define SUITE_NAME "slab"
 #define DEBUG_LOG  SUITE_NAME ".log"
-#define DATAPOOL_PATH "./slab_datapool.pelikan"
+#define SLAB_DATAPOOL_PATH "./slab_datapool.pelikan"
+#define SLAB_DATAPOOL_NAME "slab_datapool"
 
+datapool_options_st datapool_options = { DATAPOOL_OPTION(OPTION_INIT) };
 slab_options_st options = { SLAB_OPTION(OPTION_INIT) };
 slab_metrics_st metrics = { SLAB_METRIC(METRIC_INIT) };
 
@@ -27,7 +30,10 @@ static void
 test_setup(void)
 {
     option_load_default((struct option *)&options, OPTION_CARDINALITY(options));
-    options.slab_datapool.val.vstr = DATAPOOL_PATH;
+    option_load_default((struct option *)&datapool_options, OPTION_CARDINALITY(datapool_options));
+    datapool_options.datapool_path.val.vstr = SLAB_DATAPOOL_PATH;
+    datapool_options.datapool_name.val.vstr = SLAB_DATAPOOL_NAME;
+    datapool_setup(&datapool_options);
     slab_setup(&options, &metrics);
 }
 
@@ -35,8 +41,9 @@ static void
 test_teardown(int un)
 {
     slab_teardown();
+    datapool_teardown();
     if (un)
-        unlink(DATAPOOL_PATH);
+        unlink(SLAB_DATAPOOL_PATH);
 }
 
 static void
@@ -818,9 +825,11 @@ START_TEST(test_evict_lru_basic)
     options.slab_mem.val.vuint = MY_SLAB_MAXBYTES;
     options.slab_evict_opt.val.vuint = EVICT_CS;
     options.slab_item_max.val.vuint = MY_SLAB_SIZE - SLAB_HDR_SIZE;
-    options.slab_datapool.val.vstr = DATAPOOL_PATH;
+    datapool_options.datapool_path.val.vstr = SLAB_DATAPOOL_PATH;
+    datapool_options.datapool_name.val.vstr = SLAB_DATAPOOL_NAME;
 
     test_teardown(1);
+    datapool_setup(&datapool_options);
     slab_setup(&options, &metrics);
 
     for (i = 0; i < NUM_ITEMS + 1; i++) {
@@ -919,9 +928,11 @@ START_TEST(test_evict_refcount)
     options.slab_mem.val.vuint = MY_SLAB_MAXBYTES;
     options.slab_evict_opt.val.vuint = EVICT_CS;
     options.slab_item_max.val.vuint = MY_SLAB_SIZE - SLAB_HDR_SIZE;
-    options.slab_datapool.val.vstr = DATAPOOL_PATH;
+    datapool_options.datapool_path.val.vstr = SLAB_DATAPOOL_PATH;
+    datapool_options.datapool_name.val.vstr = SLAB_DATAPOOL_NAME;
 
     test_teardown(1);
+    datapool_setup(&datapool_options);
     slab_setup(&options, &metrics);
     key = str2bstr(KEY);
     val = str2bstr(VAL);