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); }