int
main(int argc, char *argv[])
{
START(argc, argv, "pmem_is_pmem_proc_linux");
if (argc < 5)
UT_FATAL("usage: %s nfiles file.. nregions "
"(addr len)... (addr len)...", argv[0]);
Nfiles = atoi(argv[1]);
UT_ASSERT(Nfiles < MAX_FILES);
for (int i = 0; i < Nfiles; i++) {
Sfile[i] = argv[2 + i];
}
Nregions = atoi(argv[2 + Nfiles]);
UT_ASSERT(Nregions < MAX_REGIONS);
for (int i = 0; i < Nregions; i += 2) {
char *str_addr = argv[3 + Nfiles + i + 0];
char *str_len = argv[3 + Nfiles + i + 1];
Mincore[i].addr = (uintptr_t)strtoull(str_addr, NULL, 16);
Mincore[i].len = (size_t)strtoull(str_len, NULL, 10);
}
for (int arg = 2 + Nfiles + 1 + 2 * Nregions; arg < argc; arg += 2) {
void *addr;
size_t len;
addr = (void *)strtoull(argv[arg], NULL, 16);
len = (size_t)strtoull(argv[arg + 1], NULL, 10);
Curfile = 0;
UT_OUT("addr %p, len %zu: %d", addr, len,
pmem_is_pmem(addr, len));
}
DONE(NULL);
}
/*
* print_reset_counters -- print and then zero all counters
*/
static void
print_reset_counters(const char *task, int tx)
{
#define CNT(name) (ops_counter.name - tx * tx_counter.name)
UT_OUT(
"%-14s %-7d %-10d %-12d %-10d %-10d %-10d %-15d %-17d %-15d %-17d %-23d",
task,
CNT(n_cl_stores),
CNT(n_drain),
CNT(n_pmem_persist),
CNT(n_pmem_msync),
CNT(n_pmem_flush),
CNT(n_pmem_drain),
CNT(n_flush_from_pmem_memcpy),
CNT(n_drain_from_pmem_memcpy),
CNT(n_flush_from_pmem_memset),
CNT(n_drain_from_pmem_memset),
CNT(n_pot_cache_misses));
#undef CNT
reset_counters();
}
/*
* test_create -- allocate all possible objects and log the number. It should
* exceed what would be possible on a single zone.
* Additionally, free one object so that we can later check that it can be
* allocated after the next open.
*/
static void
test_create(const char *path)
{
PMEMobjpool *pop = NULL;
if ((pop = pmemobj_create(path, LAYOUT_NAME,
0, S_IWUSR | S_IRUSR)) == NULL)
UT_FATAL("!pmemobj_create: %s", path);
PMEMoid oid;
int n = 0;
while (1) {
if (pmemobj_alloc(pop, &oid, ALLOC_SIZE, 0, NULL, NULL) != 0)
break;
n++;
}
UT_OUT("allocated: %d", n);
pmemobj_free(&oid);
pmemobj_close(pop);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "cto_multiple_pools");
if (argc < 4)
UT_FATAL("usage: %s directory mode npools nthreads", argv[0]);
Dir = argv[1];
char mode = argv[2][0];
Npools = ATOU(argv[3]);
unsigned nthreads = ATOU(argv[4]);
UT_OUT("create %d pools in %d thread(s)", Npools, nthreads);
Pools = CALLOC(Npools * nthreads, sizeof(Pools[0]));
Threads = CALLOC(nthreads, sizeof(Threads[0]));
Pool_idx = CALLOC(nthreads, sizeof(Pool_idx[0]));
switch (mode) {
case 'o':
test_open(nthreads);
break;
case 'c':
test_create(nthreads);
break;
default:
UT_FATAL("unknown mode");
}
FREE(Pools);
FREE(Threads);
FREE(Pool_idx);
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "util_is_poolset");
out_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR,
MAJOR_VERSION, MINOR_VERSION);
util_init();
if (argc < 2)
UT_FATAL("usage: %s file...",
argv[0]);
for (int i = 1; i < argc; i++) {
char *fname = argv[i];
int is_poolset = util_is_poolset(fname);
UT_OUT("util_is_poolset(%s): %d", fname, is_poolset);
}
out_fini();
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "obj_heap_state");
if (argc != 2)
UT_FATAL("usage: %s file-name", argv[0]);
const char *path = argv[1];
for (int i = 0; i < ALLOC_SIZE; i++)
buf[i] = rand() % 256;
PMEMobjpool *pop = NULL;
if ((pop = pmemobj_create(path, LAYOUT_NAME,
0, S_IWUSR | S_IRUSR)) == NULL)
UT_FATAL("!pmemobj_create: %s", path);
pmemobj_root(pop, ROOT_SIZE); /* just to trigger allocation */
pmemobj_close(pop);
pop = pmemobj_open(path, LAYOUT_NAME);
UT_ASSERTne(pop, NULL);
for (int i = 0; i < ALLOCS; ++i) {
PMEMoid oid;
pmemobj_alloc(pop, &oid, ALLOC_SIZE, 0,
test_constructor, NULL);
UT_OUT("%d %lu", i, oid.off);
}
pmemobj_close(pop);
DONE(NULL);
}
static PMEMobjpool *
pmemobj_open_mock(const char *fname)
{
size_t size;
int is_pmem;
void *addr = pmem_map_file(fname, 0, 0, 0, &size, &is_pmem);
if (!addr) {
UT_OUT("!%s: pmem_map_file", fname);
return NULL;
}
UT_ASSERT(size > PMEMOBJ_POOL_HDR_SIZE);
PMEMobjpool *pop = (PMEMobjpool *)addr;
VALGRIND_REMOVE_PMEM_MAPPING((char *)addr + sizeof(pop->hdr), 4096);
pop->addr = addr;
pop->size = size;
pop->is_pmem = is_pmem;
pop->rdonly = 0;
if (pop->is_pmem) {
pop->persist_local = pmem_persist;
pop->flush_local = pmem_flush;
pop->drain_local = pmem_drain;
} else {
pop->persist_local = (persist_local_fn)pmem_msync;
pop->flush_local = (persist_local_fn)pmem_msync;
pop->drain_local = pmem_drain_nop;
}
pop->persist = obj_persist;
pop->flush = obj_flush;
pop->drain = obj_drain;
return pop;
}
static void *
thread_func_create(void *arg)
{
unsigned start_idx = *(unsigned *)arg;
size_t len = strlen(Dir) + 50; /* reserve some space for pool id */
char *filename = MALLOC(sizeof(*filename) * len);
for (int repeat = 0; repeat < NREPEATS; ++repeat) {
for (unsigned idx = 0; idx < Npools; ++idx) {
unsigned pool_id = start_idx + idx;
snprintf(filename, len, "%s" OS_DIR_SEP_STR "pool%d",
Dir, pool_id);
UT_OUT("%s", filename);
/* delete old pool with the same id if exists */
if (Pools[pool_id] != NULL) {
pmemcto_close(Pools[pool_id]);
Pools[pool_id] = NULL;
UNLINK(filename);
}
Pools[pool_id] = pmemcto_create(filename, "test",
PMEMCTO_MIN_POOL, 0600);
UT_ASSERTne(Pools[pool_id], NULL);
void *ptr = pmemcto_malloc(Pools[pool_id], sizeof(int));
UT_ASSERTne(ptr, NULL);
pmemcto_free(Pools[pool_id], ptr);
}
}
FREE(filename);
return NULL;
}
int
main(int argc, char *argv[])
{
void *ptr;
START(argc, argv, "vmmalloc_malloc_hooks");
ptr = malloc(4321);
free(ptr);
ptr = calloc(1, 4321);
free(ptr);
ptr = realloc(NULL, 4321);
free(ptr);
ptr = memalign(16, 4321);
free(ptr);
UT_OUT("malloc %d realloc %d memalign %d free %d",
malloc_cnt, realloc_cnt, memalign_cnt, free_cnt);
DONE(NULL);
}
/*
* check_cpu_features -- validates CPU features detection
*/
static void
check_cpu_features(void)
{
if (is_cpu_clflush_present()) {
UT_OUT("CLFLUSH supported");
_mm_clflush(Buf);
} else {
UT_OUT("CLFLUSH not supported");
}
if (is_cpu_clflushopt_present()) {
UT_OUT("CLFLUSHOPT supported");
_mm_clflushopt(Buf);
} else {
UT_OUT("CLFLUSHOPT not supported");
}
if (is_cpu_clwb_present()) {
UT_OUT("CLWB supported");
_mm_clwb(Buf);
} else {
UT_OUT("CLWB not supported");
}
}
int
main(int argc, char *argv[])
{
START(argc, argv, "pmem_map_file");
int fd;
void *addr;
size_t mlen;
size_t *mlenp;
const char *path;
unsigned long long len;
int flags;
unsigned mode;
int is_pmem;
int *is_pmemp;
int use_mlen;
int use_is_pmem;
int err_code;
if (argc < 8)
UT_FATAL("usage: %s path len flags mode use_mlen "
"use_is_pmem err_code...", argv[0]);
for (int i = 1; i + 6 < argc; i += 7) {
path = argv[i];
len = strtoull(argv[i + 1], NULL, 0);
flags = parse_flags(argv[i + 2]);
mode = STRTOU(argv[i + 3], NULL, 8);
use_mlen = atoi(argv[i + 4]);
use_is_pmem = atoi(argv[i + 5]);
err_code = parse_err_code(argv[i + 6]);
mlen = SIZE_MAX;
if (use_mlen)
mlenp = &mlen;
else
mlenp = NULL;
if (use_is_pmem)
is_pmemp = &is_pmem;
else
is_pmemp = NULL;
UT_OUT("%s %lld %s %o %d %d %d",
path, len, argv[i + 2], mode, use_mlen,
use_is_pmem, err_code);
addr = pmem_map_file(path, len, flags, mode, mlenp, is_pmemp);
if (err_code != 0) {
UT_ASSERTeq(errno, err_code);
}
if (addr == NULL) {
UT_OUT("!pmem_map_file");
continue;
}
if (use_mlen) {
UT_ASSERTne(mlen, SIZE_MAX);
UT_OUT("mapped_len %zu", mlen);
} else {
mlen = len;
}
if (addr) {
/* is_pmem must be true for device DAX */
int is_pmem_check = pmem_is_pmem(addr, mlen);
UT_ASSERT(!is_dev_dax || is_pmem_check);
/* check is_pmem returned from pmem_map_file */
if (use_is_pmem)
UT_ASSERTeq(is_pmem, is_pmem_check);
if ((flags & PMEM_FILE_TMPFILE) == 0 && !is_dev_dax) {
fd = OPEN(argv[i], O_RDWR);
if (!use_mlen) {
os_stat_t stbuf;
FSTAT(fd, &stbuf);
mlen = (size_t)stbuf.st_size;
}
if (fd != -1) {
do_check(fd, addr, mlen);
(void) CLOSE(fd);
} else {
UT_OUT("!cannot open file: %s",
argv[i]);
}
} else {
UT_ASSERTeq(pmem_unmap(addr, mlen), 0);
}
}
}
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "blk_non_zero");
if (argc < 5)
UT_FATAL("usage: %s bsize file func [file_size] op:lba...",
argv[0]);
int read_arg = 1;
Bsize = strtoul(argv[read_arg++], NULL, 0);
const char *path = argv[read_arg++];
PMEMblkpool *handle = NULL;
switch (*argv[read_arg++]) {
case 'c': {
size_t fsize = strtoul(argv[read_arg++], NULL, 0);
handle = pmemblk_create(path, Bsize, fsize,
S_IRUSR | S_IWUSR);
if (handle == NULL)
UT_FATAL("!%s: pmemblk_create", path);
break;
}
case 'o':
handle = pmemblk_open(path, Bsize);
if (handle == NULL)
UT_FATAL("!%s: pmemblk_open", path);
break;
default:
UT_FATAL("unrecognized command %s", argv[read_arg - 1]);
}
UT_OUT("%s block size %zu usable blocks %zu",
argv[1], Bsize, pmemblk_nblock(handle));
UT_OUT("is zeroed:\t%d", is_zeroed(path));
/* map each file argument with the given map type */
for (; read_arg < argc; read_arg++) {
if (strchr("rwze", argv[read_arg][0]) == NULL ||
argv[read_arg][1] != ':')
UT_FATAL("op must be r: or w: or z: or e:");
off_t lba = strtoul(&argv[read_arg][2], NULL, 0);
unsigned char buf[Bsize];
switch (argv[read_arg][0]) {
case 'r':
if (pmemblk_read(handle, buf, lba) < 0)
UT_OUT("!read lba %zu", lba);
else
UT_OUT("read lba %zu: %s", lba,
ident(buf));
break;
case 'w':
construct(buf);
if (pmemblk_write(handle, buf, lba) < 0)
UT_OUT("!write lba %zu", lba);
else
UT_OUT("write lba %zu: %s", lba,
ident(buf));
break;
case 'z':
if (pmemblk_set_zero(handle, lba) < 0)
UT_OUT("!set_zero lba %zu", lba);
else
UT_OUT("set_zero lba %zu", lba);
break;
case 'e':
if (pmemblk_set_error(handle, lba) < 0)
UT_OUT("!set_error lba %zu", lba);
else
UT_OUT("set_error lba %zu", lba);
break;
}
}
pmemblk_close(handle);
int result = pmemblk_check(path, Bsize);
if (result < 0)
UT_OUT("!%s: pmemblk_check", path);
else if (result == 0)
UT_OUT("%s: pmemblk_check: not consistent", path);
DONE(NULL);
}
/*
* do_walk -- call pmemlog_walk() & print result
*/
static void
do_walk(PMEMlogpool *plp)
{
pmemlog_walk(plp, 0, try_to_store, NULL);
UT_OUT("walk all at once");
}
int
main(int argc, char *argv[])
{
START(argc, argv, "obj_redo_log");
util_init();
if (argc < 4)
FATAL_USAGE();
PMEMobjpool *pop = pmemobj_open_mock(argv[1]);
UT_ASSERTne(pop, NULL);
UT_ASSERTeq(util_is_zeroed((char *)pop->addr + PMEMOBJ_POOL_HDR_SIZE,
pop->size - PMEMOBJ_POOL_HDR_SIZE), 1);
char *end = NULL;
errno = 0;
size_t redo_size = strtoul(argv[2], &end, 0);
if (errno || !end || *end != '\0')
FATAL_USAGE();
UT_ASSERT(pop->size >= redo_size * sizeof(struct redo_log));
struct redo_log *redo = (struct redo_log *)pop->addr;
uint64_t offset;
uint64_t value;
int i;
int ret;
size_t index;
for (i = 3; i < argc; i++) {
char *arg = argv[i];
UT_ASSERTne(arg, NULL);
switch (arg[0]) {
case 's':
if (sscanf(arg, "s:%ld:0x%lx:0x%lx",
&index, &offset, &value) != 3)
FATAL_USAGE();
UT_OUT("s:%ld:0x%08lx:0x%08lx", index, offset, value);
redo_log_store(pop, redo, index, offset, value);
break;
case 'f':
if (sscanf(arg, "f:%ld:0x%lx:0x%lx",
&index, &offset, &value) != 3)
FATAL_USAGE();
UT_OUT("f:%ld:0x%08lx:0x%08lx", index, offset, value);
redo_log_store_last(pop, redo, index, offset,
value);
break;
case 'F':
if (sscanf(arg, "F:%ld", &index) != 1)
FATAL_USAGE();
UT_OUT("F:%ld", index);
redo_log_set_last(pop, redo, index);
break;
case 'r':
if (sscanf(arg, "r:0x%lx", &offset) != 1)
FATAL_USAGE();
uint64_t *valp = (uint64_t *)((uintptr_t)pop->addr
+ offset);
UT_OUT("r:0x%08lx:0x%08lx", offset, *valp);
break;
case 'e':
if (sscanf(arg, "e:%ld", &index) != 1)
FATAL_USAGE();
struct redo_log *entry = redo + index;
int flag = (entry->offset & REDO_FINISH_FLAG) ? 1 : 0;
offset = entry->offset & REDO_FLAG_MASK;
value = entry->value;
UT_OUT("e:%ld:0x%08lx:%d:0x%08lx", index, offset,
flag, value);
break;
case 'P':
redo_log_process(pop, redo, redo_size);
UT_OUT("P");
break;
case 'R':
redo_log_recover(pop, redo, redo_size);
UT_OUT("R");
break;
case 'C':
ret = redo_log_check(pop, redo, redo_size);
UT_OUT("C:%d", ret);
break;
default:
FATAL_USAGE();
}
}
pmemobj_close_mock(pop);
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "util_poolset");
common_init(LOG_PREFIX, LOG_LEVEL_VAR, LOG_FILE_VAR,
MAJOR_VERSION, MINOR_VERSION);
if (argc < 3)
UT_FATAL("usage: %s cmd minsize [mockopts] "
"setfile ...", argv[0]);
char *fname;
struct pool_set *set;
int ret;
size_t minsize = strtoul(argv[2], &fname, 0);
for (int arg = 3; arg < argc; arg++) {
arg += mock_options(argv[arg]);
fname = argv[arg];
struct pool_attr attr;
memset(&attr, 0, sizeof(attr));
memcpy(attr.signature, SIG, sizeof(SIG));
attr.major = 1;
switch (argv[1][0]) {
case 'c':
ret = util_pool_create(&set, fname, 0, minsize,
MIN_PART, &attr, NULL, REPLICAS_ENABLED);
if (ret == -1)
UT_OUT("!%s: util_pool_create", fname);
else {
/*
* XXX: On Windows pool files are created with
* R/W permissions, so no need for chmod().
*/
#ifndef _WIN32
util_poolset_chmod(set, S_IWUSR | S_IRUSR);
#endif
poolset_info(fname, set, 0);
util_poolset_close(set, DO_NOT_DELETE_PARTS);
}
break;
case 'o':
attr.incompat_features = TEST_FORMAT_INCOMPAT_CHECK;
ret = util_pool_open(&set, fname, 0 /* rdonly */,
MIN_PART, &attr, NULL, false, NULL);
if (ret == -1)
UT_OUT("!%s: util_pool_open", fname);
else {
poolset_info(fname, set, 1);
util_poolset_close(set, DO_NOT_DELETE_PARTS);
}
break;
case 'e':
attr.incompat_features = TEST_FORMAT_INCOMPAT_CHECK;
ret = util_pool_open(&set, fname, 0 /* rdonly */,
MIN_PART, &attr, NULL, false, NULL);
UT_ASSERTeq(ret, 0);
void *nptr = util_pool_extend(set, Extend_size);
if (nptr == NULL)
UT_OUT("!%s: util_pool_extend", fname);
else {
poolset_info(fname, set, 1);
}
util_poolset_close(set, DO_NOT_DELETE_PARTS);
break;
}
}
common_fini();
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "util_uuid_generate");
uuid_t uuid;
uuid_t uuid1;
int ret;
char conv_uu[POOL_HDR_UUID_STR_LEN];
char uu[POOL_HDR_UUID_STR_LEN];
/*
* No string passed in. Generate uuid.
*/
if (argc == 1) {
/* generate a UUID string */
ret = ut_get_uuid_str(uu);
UT_ASSERTeq(ret, 0);
/*
* Convert the the string to a uuid, convert generated
* uuid back to a string and compare strings.
*/
ret = util_uuid_from_string(uu, (struct uuid *)&uuid);
UT_ASSERTeq(ret, 0);
ret = util_uuid_to_string(uuid, conv_uu);
UT_ASSERTeq(ret, 0);
UT_ASSERT(strncmp(uu, conv_uu, POOL_HDR_UUID_STR_LEN) == 0);
/*
* Generate uuid from util_uuid_generate and translate to
* string then back to uuid to verify they match.
*/
memset(uuid, 0, sizeof(uuid_t));
memset(uu, 0, POOL_HDR_UUID_STR_LEN);
memset(conv_uu, 0, POOL_HDR_UUID_STR_LEN);
ret = util_uuid_generate(uuid);
UT_ASSERTeq(ret, 0);
ret = util_uuid_to_string(uuid, uu);
UT_ASSERTeq(ret, 0);
ret = util_uuid_from_string(uu, (struct uuid *)&uuid1);
UT_ASSERTeq(ret, 0);
UT_ASSERT(memcmp(&uuid, &uuid1, sizeof(uuid_t)) == 0);
} else {
/*
* Caller passed in string.
*/
if (strcmp(argv[2], "valid") == 0) {
ret = util_uuid_from_string(argv[1],
(struct uuid *)&uuid);
UT_ASSERTeq(ret, 0);
ret = util_uuid_to_string(uuid, conv_uu);
UT_ASSERTeq(ret, 0);
} else {
ret = util_uuid_from_string(argv[1],
(struct uuid *)&uuid);
UT_ASSERT(ret < 0);
UT_OUT("util_uuid_generate: invalid uuid string");
}
}
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "checksum");
if (argc < 2)
UT_FATAL("usage: %s files...", argv[0]);
for (int arg = 1; arg < argc; arg++) {
int fd = OPEN(argv[arg], O_RDONLY);
os_stat_t stbuf;
FSTAT(fd, &stbuf);
size_t size = (size_t)stbuf.st_size;
void *addr =
MMAP(NULL, size, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fd, 0);
uint64_t *ptr = addr;
/*
* Loop through, selecting successive locations
* where the checksum lives in this block, and
* let util_checksum() insert it so it can be
* verified against the gold standard fletcher64
* routine in this file.
*/
while ((char *)(ptr + 1) < (char *)addr + size) {
/* save whatever was at *ptr */
uint64_t oldval = *ptr;
/* mess with it */
*ptr = htole64(0x123);
/*
* calculate a checksum and have it installed
*/
util_checksum(addr, size, ptr, 1, 0);
uint64_t csum = *ptr;
/*
* verify inserted checksum checks out
*/
UT_ASSERT(util_checksum(addr, size, ptr, 0, 0));
/* put a zero where the checksum was installed */
*ptr = 0;
/* calculate a checksum */
uint64_t gold_csum = fletcher64(addr, size);
/* put the old value back */
*ptr = oldval;
/*
* verify checksum now fails
*/
UT_ASSERT(!util_checksum(addr, size, ptr,
0, 0));
/*
* verify the checksum matched the gold version
*/
UT_ASSERTeq(csum, gold_csum);
UT_OUT("%s:%" PRIu64 " 0x%" PRIx64, argv[arg],
(char *)ptr - (char *)addr, csum);
ptr++;
}
uint64_t *addr2 =
MMAP(NULL, size, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fd, 0);
uint64_t *csum = (uint64_t *)addr;
/*
* put a zero where the checksum will be installed
* in the second map
*/
*addr2 = 0;
for (size_t i = size / 8 - 1; i > 0; i -= 1) {
/* calculate a checksum and have it installed */
util_checksum(addr, size, csum, 1, i * 8);
/*
* put a zero in the second map where an ignored part is
*/
*(addr2 + i) = 0;
/* calculate a checksum */
uint64_t gold_csum = fletcher64(addr2, size);
/*
* verify the checksum matched the gold version
*/
UT_ASSERTeq(*csum, gold_csum);
}
CLOSE(fd);
MUNMAP(addr, size);
MUNMAP(addr2, size);
}
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "blk_rw");
if (argc < 5)
UT_FATAL("usage: %s bsize file func op:lba...", argv[0]);
Bsize = strtoul(argv[1], NULL, 0);
const char *path = argv[2];
PMEMblkpool *handle;
switch (*argv[3]) {
case 'c':
handle = pmemblk_create(path, Bsize, 0,
S_IWUSR | S_IRUSR);
if (handle == NULL)
UT_FATAL("!%s: pmemblk_create", path);
break;
case 'o':
handle = pmemblk_open(path, Bsize);
if (handle == NULL)
UT_FATAL("!%s: pmemblk_open", path);
break;
}
UT_OUT("%s block size %zu usable blocks %zu",
argv[1], Bsize, pmemblk_nblock(handle));
unsigned char *buf = MALLOC(Bsize);
if (buf == NULL)
UT_FATAL("cannot allocate buf");
/* map each file argument with the given map type */
for (int arg = 4; arg < argc; arg++) {
if (strchr("rwze", argv[arg][0]) == NULL || argv[arg][1] != ':')
UT_FATAL("op must be r: or w: or z: or e:");
off_t lba = strtol(&argv[arg][2], NULL, 0);
switch (argv[arg][0]) {
case 'r':
if (pmemblk_read(handle, buf, lba) < 0)
UT_OUT("!read lba %jd", lba);
else
UT_OUT("read lba %jd: %s", lba,
ident(buf));
break;
case 'w':
construct(buf);
if (pmemblk_write(handle, buf, lba) < 0)
UT_OUT("!write lba %jd", lba);
else
UT_OUT("write lba %jd: %s", lba,
ident(buf));
break;
case 'z':
if (pmemblk_set_zero(handle, lba) < 0)
UT_OUT("!set_zero lba %jd", lba);
else
UT_OUT("set_zero lba %jd", lba);
break;
case 'e':
if (pmemblk_set_error(handle, lba) < 0)
UT_OUT("!set_error lba %jd", lba);
else
UT_OUT("set_error lba %jd", lba);
break;
}
}
FREE(buf);
pmemblk_close(handle);
int result = pmemblk_check(path, Bsize);
if (result < 0)
UT_OUT("!%s: pmemblk_check", path);
else if (result == 0)
UT_OUT("%s: pmemblk_check: not consistent", path);
DONE(NULL);
}
int
main(int argc, char *argv[])
{
START(argc, argv, "vmem_delete");
VMEM *vmp;
void *ptr;
if (argc < 2)
UT_FATAL("usage: %s op:h|f|m|c|r|a|s|d", argv[0]);
/* allocate memory for function vmem_create_in_region() */
void *mem_pool = MMAP_ANON_ALIGNED(VMEM_MIN_POOL, 4 << 20);
vmp = vmem_create_in_region(mem_pool, VMEM_MIN_POOL);
if (vmp == NULL)
UT_FATAL("!vmem_create_in_region");
ptr = vmem_malloc(vmp, sizeof(long long));
if (ptr == NULL)
UT_ERR("!vmem_malloc");
vmem_delete(vmp);
/* arrange to catch SEGV */
struct sigaction v;
sigemptyset(&v.sa_mask);
v.sa_flags = 0;
v.sa_handler = signal_handler;
SIGACTION(SIGSEGV, &v, NULL);
SIGACTION(SIGABRT, &v, NULL);
SIGACTION(SIGILL, &v, NULL);
/* go through all arguments one by one */
for (int arg = 1; arg < argc; arg++) {
/* Scan the character of each argument. */
if (strchr("hfmcrasd", argv[arg][0]) == NULL ||
argv[arg][1] != '\0')
UT_FATAL("op must be one of: h, f, m, c, r, a, s, d");
switch (argv[arg][0]) {
case 'h':
UT_OUT("Testing vmem_check...");
if (!sigsetjmp(Jmp, 1)) {
UT_OUT("\tvmem_check returned %i",
vmem_check(vmp));
}
break;
case 'f':
UT_OUT("Testing vmem_free...");
if (!sigsetjmp(Jmp, 1)) {
vmem_free(vmp, ptr);
UT_OUT("\tvmem_free succeeded");
}
break;
case 'm':
UT_OUT("Testing vmem_malloc...");
if (!sigsetjmp(Jmp, 1)) {
ptr = vmem_malloc(vmp, sizeof(long long));
if (ptr != NULL)
UT_OUT("\tvmem_malloc succeeded");
else
UT_OUT("\tvmem_malloc returned NULL");
}
break;
case 'c':
UT_OUT("Testing vmem_calloc...");
if (!sigsetjmp(Jmp, 1)) {
ptr = vmem_calloc(vmp, 10, sizeof(int));
if (ptr != NULL)
UT_OUT("\tvmem_calloc succeeded");
else
UT_OUT("\tvmem_calloc returned NULL");
}
break;
case 'r':
UT_OUT("Testing vmem_realloc...");
if (!sigsetjmp(Jmp, 1)) {
ptr = vmem_realloc(vmp, ptr, 128);
if (ptr != NULL)
UT_OUT("\tvmem_realloc succeeded");
else
UT_OUT("\tvmem_realloc returned NULL");
}
break;
case 'a':
UT_OUT("Testing vmem_aligned_alloc...");
if (!sigsetjmp(Jmp, 1)) {
ptr = vmem_aligned_alloc(vmp, 128, 128);
if (ptr != NULL)
UT_OUT("\tvmem_aligned_alloc "
"succeeded");
else
UT_OUT("\tvmem_aligned_alloc"
" returned NULL");
}
break;
case 's':
UT_OUT("Testing vmem_strdup...");
if (!sigsetjmp(Jmp, 1)) {
ptr = vmem_strdup(vmp, "Test string");
if (ptr != NULL)
UT_OUT("\tvmem_strdup succeeded");
else
UT_OUT("\tvmem_strdup returned NULL");
}
break;
case 'd':
UT_OUT("Testing vmem_delete...");
if (!sigsetjmp(Jmp, 1)) {
vmem_delete(vmp);
if (errno != 0)
UT_OUT("\tvmem_delete failed: %s",
vmem_errormsg());
else
UT_OUT("\tvmem_delete succeeded");
}
break;
}
}
DONE(NULL);
}
