/*
* test_create -- test case for creating remote pool
*/
static int
test_create(const struct test_case *tc, int argc, char *argv[])
{
if (argc < 5)
UT_FATAL("usage: test_create <id> <pool set> "
"<target> <pool> <size>");
const char *id_str = argv[0];
const char *pool_set = argv[1];
const char *target = argv[2];
const char *pool_path = argv[3];
const char *size_str = argv[4];
unsigned nlanes = NLANES;
int id = atoi(id_str);
UT_ASSERT(id >= 0 && id < MAX_IDS);
struct pool_entry *pool = &pools[id];
UT_ASSERTeq(pool->rpp, NULL);
init_pool(pool, pool_path, size_str);
struct rpmem_pool_attr pool_attr = POOL_ATTR_INIT;
pool->rpp = rpmem_create(target, pool_set, pool->pool,
pool->size, &nlanes, &pool_attr);
if (pool->rpp) {
UT_ASSERTne(nlanes, 0);
UT_OUT("%s: created", pool_set);
} else {
UT_OUT("!%s", pool_set);
free_pool(pool);
}
return 5;
}
int
main(int argc, char *argv[])
{
int ret;
unsigned nlanes = NLANES;
/* fill pool_attributes */
struct rpmem_pool_attr pool_attr;
memset(&pool_attr, 0, sizeof(pool_attr));
/* create a remote pool */
RPMEMpool *rpp = rpmem_create("localhost", "pool.set",
pool, POOL_SIZE, &nlanes, &pool_attr);
if (!rpp) {
fprintf(stderr, "rpmem_create: %s\n", rpmem_errormsg());
return 1;
}
/* store data on local pool */
memset(pool, 0, POOL_SIZE);
/* make local data persistent on remote node */
ret = rpmem_persist(rpp, 0, POOL_SIZE, 0);
if (ret) {
fprintf(stderr, "rpmem_persist: %s\n", rpmem_errormsg());
return 1;
}
/* close the remote pool */
ret = rpmem_close(rpp);
if (ret) {
fprintf(stderr, "rpmem_close: %s\n", rpmem_errormsg());
return 1;
}
return 0;
}
int
main(int argc, char *argv[])
{
int ret = 0;
if (argc < 4) {
fprintf(stderr, "usage: %s [create|open|remove]"
" <target> <pool_set> [options]\n", argv[0]);
return 1;
}
char *op = argv[1];
char *target = argv[2];
char *pool_set = argv[3];
unsigned nlanes = NLANES;
void *pool;
size_t align = sysconf(_SC_PAGESIZE);
errno = posix_memalign(&pool, align, POOL_SIZE);
if (errno) {
perror("posix_memalign");
return -1;
}
if (strcmp(op, "create") == 0) {
struct rpmem_pool_attr pool_attr;
default_attr(&pool_attr);
RPMEMpool *rpp = rpmem_create(target, pool_set,
pool, POOL_SIZE, &nlanes, &pool_attr);
if (!rpp) {
fprintf(stderr, "rpmem_create: %s\n",
rpmem_errormsg());
ret = 1;
goto end;
}
ret = rpmem_persist(rpp, 0, POOL_SIZE, 0);
if (ret)
fprintf(stderr, "rpmem_persist: %s\n",
rpmem_errormsg());
ret = rpmem_close(rpp);
if (ret)
fprintf(stderr, "rpmem_close: %s\n",
rpmem_errormsg());
} else if (strcmp(op, "open") == 0) {
struct rpmem_pool_attr def_attr;
default_attr(&def_attr);
struct rpmem_pool_attr pool_attr;
RPMEMpool *rpp = rpmem_open(target, pool_set,
pool, POOL_SIZE, &nlanes, &pool_attr);
if (!rpp) {
fprintf(stderr, "rpmem_open: %s\n",
rpmem_errormsg());
ret = 1;
goto end;
}
if (memcmp(&def_attr, &pool_attr, sizeof(def_attr))) {
fprintf(stderr, "remote pool not consistent\n");
}
ret = rpmem_persist(rpp, 0, POOL_SIZE, 0);
if (ret)
fprintf(stderr, "rpmem_persist: %s\n",
rpmem_errormsg());
ret = rpmem_close(rpp);
if (ret)
fprintf(stderr, "rpmem_close: %s\n",
rpmem_errormsg());
} else if (strcmp(op, "remove") == 0) {
ret = rpmem_remove(target, pool_set, 0);
if (ret)
fprintf(stderr, "removing pool failed: %s\n",
rpmem_errormsg());
} else {
fprintf(stderr, "unsupported operation -- '%s'\n", op);
ret = 1;
}
end:
free(pool);
return ret;
}
