自学教程：C++ ASSERTne函数代码示例

/* * util_parse_add_part -- (internal) add a new part file to the replica info */static intutil_parse_add_part(struct pool_set *set, const char *path, size_t filesize){	LOG(3, "set %p path %s filesize %zu", set, path, filesize);	ASSERTne(set, NULL);	struct pool_replica *rep = set->replica[set->nreplicas - 1];	ASSERTne(rep, NULL);	/* XXX - pre-allocate space for X parts, and reallocate every X parts */	rep = Realloc(rep, sizeof (struct pool_replica) +			(rep->nparts + 1) * sizeof (struct pool_set_part));	if (rep == NULL) {		ERR("!Realloc");		return -1;	}	set->replica[set->nreplicas - 1] = rep;	unsigned p = rep->nparts++;	rep->part[p].path = path;	rep->part[p].filesize = filesize;	rep->part[p].fd = -1;	rep->part[p].addr = NULL;	rep->part[p].created = 0;	return 0;}

/* * util_parse_add_replica -- (internal) add a new replica to the pool set info */static intutil_parse_add_replica(struct pool_set **setp){	LOG(3, "setp %p", setp);	ASSERTne(setp, NULL);	struct pool_set *set = *setp;	ASSERTne(set, NULL);	set = Realloc(set, sizeof (struct pool_set) +			(set->nreplicas + 1) * sizeof (struct pool_replica *));	if (set == NULL) {		ERR("!Realloc");		return -1;	}	*setp = set;	struct pool_replica *rep;	rep = Malloc(sizeof (struct pool_replica));	if (rep == NULL) {		ERR("!Malloc");		return -1;	}	unsigned r = set->nreplicas++;	set->replica[r] = rep;	rep->nparts = 0;	rep->repsize = 0;	return 0;}

/* * util_parse_add_remote_replica -- (internal) add a new remote replica *                                  to the pool set info */static intutil_parse_add_remote_replica(struct pool_set **setp, char *node_addr,				char *pool_desc){	LOG(3, "setp %p node_addr %s pool_desc %s", setp, node_addr, pool_desc);	ASSERTne(setp, NULL);	ASSERTne(node_addr, NULL);	ASSERTne(pool_desc, NULL);	int ret = util_parse_add_replica(setp);	if (ret != 0)		return ret;	/* a remote replica has one 'fake' part */	ret = util_parse_add_part(*setp, NULL, 0);	if (ret != 0)		return ret;	struct pool_set *set = *setp;	struct pool_replica *rep = set->replica[set->nreplicas - 1];	ASSERTne(rep, NULL);	rep->remote = Zalloc(sizeof(struct remote_replica));	if (rep->remote == NULL) {		ERR("!Malloc");		return -1;	}	rep->remote->node_addr = node_addr;	rep->remote->pool_desc = pool_desc;	set->remote = 1;	return 0;}

/* * constructor_zrealloc -- (internal) constructor for pmemobj_zrealloc */static voidconstructor_zrealloc(PMEMobjpool *pop, void *ptr, void *arg){	LOG(3, "pop %p ptr %p arg %p", pop, ptr, arg);	ASSERTne(ptr, NULL);	ASSERTne(arg, NULL);	struct carg_realloc *carg = arg;	struct oob_header *pobj = OOB_HEADER_FROM_PTR(ptr);	if (ptr != carg->ptr) {		size_t cpy_size = carg->new_size > carg->old_size ?			carg->old_size : carg->new_size;		pop->memcpy_persist(pop, ptr, carg->ptr, cpy_size);		pobj->data.internal_type = TYPE_ALLOCATED;		pobj->data.user_type = carg->user_type;		pop->persist(pop, &pobj->data.internal_type,		/* there's no padding between these, so we can add sizes */			sizeof (pobj->data.internal_type) +			sizeof (pobj->data.user_type));		VALGRIND_DO_MAKE_MEM_NOACCESS(pop, &pobj->data.padding,				sizeof (pobj->data.padding));	}	if (carg->new_size > carg->old_size) {		size_t grow_len = carg->new_size - carg->old_size;		void *new_data_ptr = (void *)((uintptr_t)ptr + carg->old_size);		pop->memset_persist(pop, new_data_ptr, 0, grow_len);	}}

/* * constructor_zrealloc_root -- (internal) constructor for pmemobj_root */static voidconstructor_zrealloc_root(PMEMobjpool *pop, void *ptr,	size_t usable_size, void *arg){	LOG(3, "pop %p ptr %p arg %p", pop, ptr, arg);	ASSERTne(ptr, NULL);	ASSERTne(arg, NULL);	struct carg_realloc *carg = arg;	VALGRIND_ADD_TO_TX(OOB_HEADER_FROM_PTR(ptr),		usable_size + OBJ_OOB_SIZE);	constructor_realloc(pop, ptr, usable_size, arg);	/* activate the padding redzone */	VALGRIND_DO_MAKE_MEM_NOACCESS(pop,		&OOB_HEADER_FROM_PTR(ptr)->data.padding,		sizeof (OOB_HEADER_FROM_PTR(ptr)->data.padding));	if (carg->constructor)		carg->constructor(pop, ptr, carg->arg);	VALGRIND_REMOVE_FROM_TX(OOB_HEADER_FROM_PTR(ptr),		carg->new_size + OBJ_OOB_SIZE);}

static void *do_test(void *arg){	int **bufs = malloc(NBUFS * sizeof (void *));	ASSERTne(bufs, NULL);	size_t *sizes = malloc(NBUFS * sizeof (size_t));	ASSERTne(sizes, NULL);	for (int j = 0; j < NBUFS; j++) {		sizes[j] = sizeof (int) + 64 * (rand() % 100);		bufs[j] = malloc(sizes[j]);		ASSERTne(bufs[j], NULL);	}	for (int j = 0; j < NBUFS; j++) {		ASSERT(malloc_usable_size(bufs[j]) >= sizes[j]);		free(bufs[j]);	}	free(sizes);	free(bufs);	return NULL;}

/* * constructor_alloc_bytype -- (internal) constructor for obj_alloc_construct */static voidconstructor_alloc_bytype(PMEMobjpool *pop, void *ptr,	size_t usable_size, void *arg){	LOG(3, "pop %p ptr %p arg %p", pop, ptr, arg);	ASSERTne(ptr, NULL);	ASSERTne(arg, NULL);	struct oob_header *pobj = OOB_HEADER_FROM_PTR(ptr);	struct carg_bytype *carg = arg;	pobj->data.internal_type = TYPE_ALLOCATED;	pobj->data.user_type = carg->user_type;	pop->flush(pop, &pobj->data.internal_type,		/* there's no padding between these, so we can add sizes */		sizeof (pobj->data.internal_type) +		sizeof (pobj->data.user_type));	if (carg->zero_init)		pop->memset_persist(pop, ptr, 0, usable_size);	else		pop->drain(pop);	VALGRIND_DO_MAKE_MEM_NOACCESS(pop, &pobj->data.padding,			sizeof (pobj->data.padding));	if (carg->constructor)		carg->constructor(pop, ptr, carg->arg);}

intmain(int argc, char *argv[]){	char *dir = NULL;	void *mem_pool = NULL;	VMEM *vmp;	START(argc, argv, "vmem_check");	if (argc == 2) {		dir = argv[1];	} else if (argc > 2) {		FATAL("usage: %s [directory]", argv[0]);	}	if (dir == NULL) {		/* allocate memory for function vmem_create_in_region() */		mem_pool = MMAP(NULL, VMEM_MIN_POOL*2, PROT_READ|PROT_WRITE,					MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);		vmp = vmem_create_in_region(mem_pool, VMEM_MIN_POOL);		if (vmp == NULL)			FATAL("!vmem_create_in_region");	} else {		vmp = vmem_create(dir, VMEM_MIN_POOL);		if (vmp == NULL)			FATAL("!vmem_create");	}	ASSERTeq(1, vmem_check(vmp));	/* create pool in this same memory region */	if (dir == NULL) {		unsigned long Pagesize = (unsigned long) sysconf(_SC_PAGESIZE);		void *mem_pool2 = (void *)(((uintptr_t)mem_pool +			VMEM_MIN_POOL/2) & ~(Pagesize-1));		VMEM *vmp2 = vmem_create_in_region(mem_pool2,			VMEM_MIN_POOL);		if (vmp2 == NULL)			FATAL("!vmem_create_in_region");		/* detect memory range collision */		ASSERTne(1, vmem_check(vmp));		ASSERTne(1, vmem_check(vmp2));		vmem_delete(vmp2);		ASSERTne(1, vmem_check(vmp2));	}	vmem_delete(vmp);	/* for vmem_create() memory unmapped after delete pool */	if (!dir)		ASSERTne(1, vmem_check(vmp));	DONE(NULL);}

/* * lane_init -- (internal) initializes a single lane runtime variables */static intlane_init(PMEMobjpool *pop, struct lane *lane, struct lane_layout *layout,		pthread_mutex_t *mtx, pthread_mutexattr_t *attr){	ASSERTne(lane, NULL);	ASSERTne(mtx, NULL);	ASSERTne(attr, NULL);	int err;	util_mutex_init(mtx, attr);	lane->lock = mtx;	int i;	for (i = 0; i < MAX_LANE_SECTION; ++i) {		lane->sections[i].runtime = NULL;		lane->sections[i].layout = &layout->sections[i];		err = Section_ops[i]->construct(pop, &lane->sections[i]);		if (err != 0) {			ERR("!lane_construct_ops %d", i);			goto error_section_construct;		}	}	return 0;error_section_construct:	for (i = i - 1; i >= 0; --i)		Section_ops[i]->destruct(pop, &lane->sections[i]);	util_mutex_destroy(lane->lock);	return err;}

/* * constructor_alloc_root -- (internal) constructor for obj_alloc_root */static voidconstructor_alloc_root(PMEMobjpool *pop, void *ptr, void *arg){	LOG(3, "pop %p ptr %p arg %p", pop, ptr, arg);	ASSERTne(ptr, NULL);	ASSERTne(arg, NULL);	struct oob_header *ro = OOB_HEADER_FROM_PTR(ptr);	struct carg_root *carg = arg;	/* temporarily add atomic root allocation to pmemcheck transaction */	VALGRIND_ADD_TO_TX(ro, OBJ_OOB_SIZE + carg->size);	if (carg->constructor)		carg->constructor(pop, ptr, carg->arg);	else		pop->memset_persist(pop, ptr, 0, carg->size);	ro->data.internal_type = TYPE_ALLOCATED;	ro->data.user_type = POBJ_ROOT_TYPE_NUM;	ro->size = carg->size;	VALGRIND_REMOVE_FROM_TX(ro, OBJ_OOB_SIZE + carg->size);	pop->persist(pop, &ro->size,		/* there's no padding between these, so we can add sizes */		sizeof (ro->size) + sizeof (ro->data.internal_type) +		sizeof (ro->data.user_type));	VALGRIND_DO_MAKE_MEM_NOACCESS(pop, &ro->data.padding,			sizeof (ro->data.padding));}

intmain(int argc, char *argv[]){	char *dir = NULL;	void *mem_pool = NULL;	VMEM *vmp;	START(argc, argv, "vmem_check");	if (argc == 2) {		dir = argv[1];	} else if (argc > 2) {		FATAL("usage: %s [directory]", argv[0]);	}	if (dir == NULL) {		/* allocate memory for function vmem_create_in_region() */		mem_pool = MMAP_ANON_ALIGNED(VMEM_MIN_POOL * 2, 4 << 20);		vmp = vmem_create_in_region(mem_pool, VMEM_MIN_POOL);		if (vmp == NULL)			FATAL("!vmem_create_in_region");	} else {		vmp = vmem_create(dir, VMEM_MIN_POOL);		if (vmp == NULL)			FATAL("!vmem_create");	}	ASSERTeq(1, vmem_check(vmp));	/* create pool in this same memory region */	if (dir == NULL) {		void *mem_pool2 = (void *)(((uintptr_t)mem_pool +			VMEM_MIN_POOL / 2) & ~(Ut_pagesize - 1));		VMEM *vmp2 = vmem_create_in_region(mem_pool2,			VMEM_MIN_POOL);		if (vmp2 == NULL)			FATAL("!vmem_create_in_region");		/* detect memory range collision */		ASSERTne(1, vmem_check(vmp));		ASSERTne(1, vmem_check(vmp2));		vmem_delete(vmp2);		ASSERTne(1, vmem_check(vmp2));	}	vmem_delete(vmp);	/* for vmem_create() memory unmapped after delete pool */	if (!dir)		ASSERTne(1, vmem_check(vmp));	DONE(NULL);}

intmain(int argc, char *argv[]){	const int test_value = 123456;	char *dir = NULL;	void *mem_pool = NULL;	VMEM *vmp;	START(argc, argv, "vmem_realloc");	if (argc == 2) {		dir = argv[1];	} else if (argc > 2) {		FATAL("usage: %s [directory]", argv[0]);	}	if (dir == NULL) {		/* allocate memory for function vmem_create_in_region() */		mem_pool = MMAP(NULL, VMEM_MIN_POOL, PROT_READ|PROT_WRITE,					MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);		vmp = vmem_create_in_region(mem_pool, VMEM_MIN_POOL);		if (vmp == NULL)			FATAL("!vmem_create_in_region");	} else {		vmp = vmem_create(dir, VMEM_MIN_POOL);		if (vmp == NULL)			FATAL("!vmem_create");	}	int *test = vmem_realloc(vmp, NULL, sizeof (int));	ASSERTne(test, NULL);	test[0] = test_value;	ASSERTeq(test[0], test_value);	/* check that pointer came from mem_pool */	if (dir == NULL) {		ASSERTrange(test, mem_pool, VMEM_MIN_POOL);	}	test = vmem_realloc(vmp, test, sizeof (int) * 10);	ASSERTne(test, NULL);	ASSERTeq(test[0], test_value);	test[1] = test_value;	test[9] = test_value;	/* check that pointer came from mem_pool */	if (dir == NULL) {		ASSERTrange(test, mem_pool, VMEM_MIN_POOL);	}	vmem_free(vmp, test);	vmem_delete(vmp);	DONE(NULL);}

/* * alloc_class_find_min_frag -- searches for an existing allocation * class that will provide the smallest internal fragmentation for the given * size. */static struct alloc_class *alloc_class_find_min_frag(struct alloc_class_collection *ac, size_t n){	LOG(10, NULL);	struct alloc_class *best_c = NULL;	size_t lowest_waste = SIZE_MAX;	ASSERTne(n, 0);	/*	 * Start from the largest buckets in order to minimize unit size of	 * allocated memory blocks.	 */	for (int i = MAX_ALLOCATION_CLASSES - 1; i >= 0; --i) {		struct alloc_class *c = ac->aclasses[i];		/* can't use alloc classes /w no headers by default */		if (c == NULL || c->header_type == HEADER_NONE)			continue;		size_t real_size = n + header_type_to_size[c->header_type];		size_t units = CALC_SIZE_IDX(c->unit_size, real_size);		/* can't exceed the maximum allowed run unit max */		if (c->type == CLASS_RUN && units > RUN_UNIT_MAX_ALLOC)			continue;		if (c->unit_size * units == real_size)			return c;		size_t waste = (c->unit_size * units) - real_size;		/*		 * If we assume that the allocation class is only ever going to		 * be used with exactly one size, the effective internal		 * fragmentation would be increased by the leftover		 * memory at the end of the run.		 */		if (c->type == CLASS_RUN) {			size_t wasted_units = c->run.nallocs % units;			size_t wasted_bytes = wasted_units * c->unit_size;			size_t waste_avg_per_unit = wasted_bytes /				c->run.nallocs;			waste += waste_avg_per_unit;		}		if (best_c == NULL || lowest_waste > waste) {			best_c = c;			lowest_waste = waste;		}	}	ASSERTne(best_c, NULL);	return best_c;}

intmain(int argc, char *argv[]){	void *handle = NULL;	void *ptr;	START(argc, argv, "vmmalloc_init");	if (argc > 2)		FATAL("usage: %s [d|l]", argv[0]);	if (argc == 2) {		switch (argv[1][0]) {		case 'd':			OUT("deep binding");			handle = dlopen("./libtest.so",				RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND);			break;		case 'l':			OUT("lazy binding");			handle = dlopen("./libtest.so", RTLD_LAZY);			break;		default:			FATAL("usage: %s [d|l]", argv[0]);		}		if (handle == NULL)			OUT("dlopen: %s", dlerror());		ASSERTne(handle, NULL);		Falloc = dlsym(handle, "falloc");		ASSERTne(Falloc, NULL);	}	ptr = malloc(4321);	free(ptr);	if (argc == 2) {		/*		 * NOTE: falloc calls malloc internally.		 * If libtest is loaded with RTLD_DEEPBIND flag, then it will		 * use its own lookup scope in preference to global symbols		 * from already loaded (LD_PRELOAD) libvmmalloc.  So, falloc		 * will call the stock libc's malloc.		 * However, since we override the malloc hooks, a call to libc's		 * malloc will be redirected to libvmmalloc anyway, and the		 * memory can be safely reclaimed using libvmmalloc's free.		 */		ptr = Falloc(4321, 0xaa);		free(ptr);	}	DONE(NULL);}

/* * constructor_zalloc -- (internal) constructor for pmemobj_zalloc */static voidconstructor_zalloc(PMEMobjpool *pop, void *ptr, void *arg){	LOG(3, "pop %p ptr %p arg %p", pop, ptr, arg);	ASSERTne(ptr, NULL);	ASSERTne(arg, NULL);	struct carg_alloc *carg = arg;	pop->memset_persist(pop, ptr, 0, carg->size);}

/* * constructor_strdup -- (internal) constructor of pmemobj_strndup */static voidconstructor_strdup(PMEMobjpool *pop, void *ptr, void *arg){	LOG(3, "pop %p ptr %p arg %p", pop, ptr, arg);	ASSERTne(ptr, NULL);	ASSERTne(arg, NULL);	struct carg_strdup *carg = arg;	/* copy string */	pop->memcpy_persist(pop, ptr, carg->s, carg->size);}

/* * alloc_class_find_min_frag -- searches for an existing allocation * class that will provide the smallest internal fragmentation for the given * size. */static struct alloc_class *alloc_class_find_min_frag(struct alloc_class_collection *ac, size_t n){	LOG(10, NULL);	struct alloc_class *best_c = NULL;	size_t best_frag_d = SIZE_MAX;	size_t best_frag_r = SIZE_MAX;	ASSERTne(n, 0);	/*	 * Start from the largest buckets in order to minimize unit size of	 * allocated memory blocks.	 */	for (int i = MAX_ALLOCATION_CLASSES - 1; i >= 0; --i) {		struct alloc_class *c = ac->aclasses[i];		/* can't use alloc classes /w no headers by default */		if (c == NULL || c->header_type == HEADER_NONE)			continue;		size_t real_size = n + header_type_to_size[c->header_type];		size_t units = CALC_SIZE_IDX(c->unit_size, real_size);		/* can't exceed the maximum allowed run unit max */		if (units > RUN_UNIT_MAX_ALLOC)			continue;		if (c->unit_size * units == real_size)			return c;		ASSERT(c->unit_size * units > real_size);		size_t frag_d = (c->unit_size * units) / real_size;		size_t frag_r = (c->unit_size * units) % real_size;		if (best_c == NULL || frag_d < best_frag_d ||			(frag_d == best_frag_d && frag_r < best_frag_r)) {			best_c = c;			best_frag_d = frag_d;			best_frag_r = frag_r;		}	}	ASSERTne(best_c, NULL);	return best_c;}

/* * pool_test -- test pool * * This function creates a memory pool in a file (if dir is not NULL), * or in RAM (if dir is NULL) and allocates memory for the test. */voidpool_test(const char *dir){	VMEM *vmp = NULL;	if (dir != NULL) {		vmp = vmem_pool_create(dir, VMEM_MIN_POOL);	} else {		vmp = vmem_pool_create_in_region(mem_pool, VMEM_MIN_POOL);	}	if (expect_create_pool == 0) {		ASSERTeq(vmp, NULL);		DONE(NULL);	} else {		if (vmp == NULL) {			if (dir == NULL) {				FATAL("!vmem_pool_create_in_region");			} else {				FATAL("!vmem_pool_create");			}		}	}	char *test = vmem_malloc(vmp, strlen(TEST_STRING_VALUE) + 1);	ASSERTne(test, NULL);	strcpy(test, TEST_STRING_VALUE);	ASSERTeq(strcmp(test, TEST_STRING_VALUE), 0);	vmem_free(vmp, test);	vmem_pool_delete(vmp);}

/* * alloc_class_assign_by_size -- (internal) chooses the allocation class that *	best approximates the provided size */static struct alloc_class *alloc_class_assign_by_size(struct alloc_class_collection *ac,	size_t size){	LOG(10, NULL);	size_t class_map_index = SIZE_TO_CLASS_MAP_INDEX(size,		ac->granularity);	struct alloc_class *c = alloc_class_find_min_frag(ac,		class_map_index * ac->granularity);	ASSERTne(c, NULL);	/*	 * We don't lock this array because locking this section here and then	 * bailing out if someone else was faster would be still slower than	 * just calculating the class and failing to assign the variable.	 * We are using a compare and swap so that helgrind/drd don't complain.	 */	util_bool_compare_and_swap64(		&ac->class_map_by_alloc_size[class_map_index],		MAX_ALLOCATION_CLASSES, c->id);	return c;}

/* * util_file_create -- create a new memory pool file */intutil_file_create(const char *path, size_t size, size_t minsize){	LOG(3, "path %s size %zu minsize %zu", path, size, minsize);	ASSERTne(size, 0);	if (size < minsize) {		ERR("size %zu smaller than %zu", size, minsize);		errno = EINVAL;		return -1;	}	if (((off_t)size) < 0) {		ERR("invalid size (%zu) for off_t", size);		errno = EFBIG;		return -1;	}	int fd;	int mode;	int flags = O_RDWR | O_CREAT | O_EXCL;#ifndef _WIN32	mode = 0;#else	mode = S_IWRITE | S_IREAD;	flags |= O_BINARY;#endif	/*	 * Create file without any permission. It will be granted once	 * initialization completes.	 */	if ((fd = open(path, flags, mode)) < 0) {		ERR("!open %s", path);		return -1;	}	if ((errno = posix_fallocate(fd, 0, (off_t)size)) != 0) {		ERR("!posix_fallocate");		goto err;	}	/* for windows we can't flock until after we fallocate */	if (flock(fd, LOCK_EX | LOCK_NB) < 0) {		ERR("!flock");		goto err;	}	return fd;err:	LOG(4, "error clean up");	int oerrno = errno;	if (fd != -1)		(void) close(fd);	unlink(path);	errno = oerrno;	return -1;}

intmain(int argc, char *argv[]){	START(argc, argv, "obj_heap_state");	if (argc != 2)		FATAL("usage: %s file-name", argv[0]);	const char *path = argv[1];	PMEMobjpool *pop = NULL;	if ((pop = pmemobj_create(path, LAYOUT_NAME,			PMEMOBJ_MIN_POOL, S_IWUSR | S_IRUSR)) == NULL)		FATAL("!pmemobj_create: %s", path);	pmemobj_root(pop, ROOT_SIZE); /* just to trigger allocation */	pmemobj_close(pop);	pop = pmemobj_open(path, LAYOUT_NAME);	ASSERTne(pop, NULL);	for (int i = 0; i < ALLOCS; ++i) {		PMEMoid oid;		pmemobj_alloc(pop, &oid, ALLOC_SIZE, 0, NULL, NULL);		OUT("%d %lu", i, oid.off);	}	pmemobj_close(pop);	DONE(NULL);}

/* * container_seglists_insert_block -- (internal) inserts a new memory block *	into the container */static intcontainer_seglists_insert_block(struct block_container *bc,	const struct memory_block *m){	ASSERT(m->chunk_id < MAX_CHUNK);	ASSERT(m->zone_id < UINT16_MAX);	ASSERTne(m->size_idx, 0);	struct block_container_seglists *c =		(struct block_container_seglists *)bc;	if (c->nonempty_lists == 0)		c->m = *m;	ASSERT(m->size_idx <= SEGLIST_BLOCK_LISTS);	ASSERT(m->chunk_id == c->m.chunk_id);	ASSERT(m->zone_id == c->m.zone_id);	if (VECQ_ENQUEUE(&c->blocks[m->size_idx - 1], m->block_off) != 0)		return -1;	/* marks the list as nonempty */	c->nonempty_lists |= 1ULL << (m->size_idx - 1);	return 0;}

/* * pool_hdr_default -- return default pool header values */voidpool_hdr_default(enum pool_type type, struct pool_hdr *hdrp){	memset(hdrp, 0, sizeof(*hdrp));	const char *sig = pool_get_signature(type);	ASSERTne(sig, NULL);	memcpy(hdrp->signature, sig, POOL_HDR_SIG_LEN);	switch (type) {	case POOL_TYPE_LOG:		hdrp->major = LOG_FORMAT_MAJOR;		hdrp->compat_features = LOG_FORMAT_COMPAT;		hdrp->incompat_features = LOG_FORMAT_INCOMPAT;		hdrp->ro_compat_features = LOG_FORMAT_RO_COMPAT;		break;	case POOL_TYPE_BLK:		hdrp->major = BLK_FORMAT_MAJOR;		hdrp->compat_features = BLK_FORMAT_COMPAT;		hdrp->incompat_features = BLK_FORMAT_INCOMPAT;		hdrp->ro_compat_features = BLK_FORMAT_RO_COMPAT;		break;	case POOL_TYPE_OBJ:		hdrp->major = OBJ_FORMAT_MAJOR;		hdrp->compat_features = OBJ_FORMAT_COMPAT;		hdrp->incompat_features = OBJ_FORMAT_INCOMPAT;		hdrp->ro_compat_features = OBJ_FORMAT_RO_COMPAT;		break;	default:		break;	}}

/* * list_mutexes_lock -- (internal) grab one or two locks in ascending * address order */static inline intlist_mutexes_lock(PMEMobjpool *pop,	struct list_head *head1, struct list_head *head2){	ASSERTne(head1, NULL);	if (!head2 || head1 == head2)		return pmemobj_mutex_lock(pop, &head1->lock);	PMEMmutex *lock1;	PMEMmutex *lock2;	if ((uintptr_t)&head1->lock < (uintptr_t)&head2->lock) {		lock1 = &head1->lock;		lock2 = &head2->lock;	} else {		lock1 = &head2->lock;		lock2 = &head1->lock;	}	int ret;	if ((ret = pmemobj_mutex_lock(pop, lock1)))		goto err;	if ((ret = pmemobj_mutex_lock(pop, lock2)))		goto err_unlock;	return 0;err_unlock:	pmemobj_mutex_unlock(pop, lock1);err:	return ret;}

/* * util_map_part -- (internal) map a header of a pool set */static intutil_map_hdr(struct pool_set_part *part, size_t size,		off_t offset, int flags){	LOG(3, "part %p size %zu offset %ju flags %d",		part, size, offset, flags);	ASSERTne(size, 0);	ASSERTeq(size % Pagesize, 0);	ASSERTeq(offset % Pagesize, 0);	part->hdrsize = size;	part->hdr = mmap(NULL, part->hdrsize,		PROT_READ|PROT_WRITE, flags, part->fd, offset);	if (part->hdr == MAP_FAILED) {		ERR("!mmap: %s", part->path);		return -1;	}	VALGRIND_REGISTER_PMEM_MAPPING(part->hdr, part->hdrsize);	VALGRIND_REGISTER_PMEM_FILE(part->fd, part->hdr, part->hdrsize, offset);	return 0;}

/* * pool_hdr_default -- return default pool header values */voidpool_hdr_default(enum pool_type type, struct pool_hdr *hdrp){	memset(hdrp, 0, sizeof(*hdrp));	const char *sig = pool_get_signature(type);	ASSERTne(sig, NULL);	memcpy(hdrp->signature, sig, POOL_HDR_SIG_LEN);	switch (type) {	case POOL_TYPE_LOG:		hdrp->major = LOG_FORMAT_MAJOR;		hdrp->features = log_format_feat_default;		break;	case POOL_TYPE_BLK:		hdrp->major = BLK_FORMAT_MAJOR;		hdrp->features = blk_format_feat_default;		break;	case POOL_TYPE_OBJ:		hdrp->major = OBJ_FORMAT_MAJOR;		hdrp->features = obj_format_feat_default;		break;	default:		break;	}}

/* * pool_hdr_nondefault_fix -- (internal) fix custom value fields */static intpool_hdr_nondefault_fix(PMEMpoolcheck *ppc, location *loc, uint32_t question,	void *context){	LOG(3, NULL);	ASSERTne(loc, NULL);	uint64_t *flags = NULL;	switch (question) {	case Q_CRTIME:		CHECK_INFO(ppc, "%ssetting pool_hdr.crtime to file's modtime: "			"%s", loc->prefix,			check_get_time_str(ppc->pool->set_file->mtime));		util_convert2h_hdr_nocheck(&loc->hdr);		loc->hdr.crtime = (uint64_t)ppc->pool->set_file->mtime;		util_convert2le_hdr(&loc->hdr);		break;	case Q_ARCH_FLAGS:		flags = (uint64_t *)&loc->valid_part_hdrp->arch_flags;		CHECK_INFO(ppc, "%ssetting pool_hdr.arch_flags to 0x%08" PRIx64				"%08" PRIx64, loc->prefix, flags[0], flags[1]);		util_convert2h_hdr_nocheck(&loc->hdr);		memcpy(&loc->hdr.arch_flags, &loc->valid_part_hdrp->arch_flags,			sizeof(struct arch_flags));		util_convert2le_hdr(&loc->hdr);		break;	default:		ERR("not implemented question id: %u", question);	}	return 0;}

/* * pool_hdr_uuid_fix -- (internal) fix UUID value */static intpool_hdr_uuid_fix(PMEMpoolcheck *ppc, location *loc, uint32_t question,	void *context){	LOG(3, NULL);	ASSERTne(loc, NULL);	switch (question) {	case Q_UUID_SET:		CHECK_INFO(ppc, "%ssetting pool_hdr.uuid to %s", loc->prefix,			check_get_uuid_str(*loc->valid_uuid));		memcpy(loc->hdr.uuid, loc->valid_uuid, POOL_HDR_UUID_LEN);		break;	case Q_UUID_REGENERATE:		if (util_uuid_generate(loc->hdr.uuid) != 0) {			ppc->result = CHECK_RESULT_INTERNAL_ERROR;			return CHECK_ERR(ppc, "%suuid generation failed",				loc->prefix);		}		CHECK_INFO(ppc, "%ssetting pool_hdr.uuid to %s", loc->prefix,			check_get_uuid_str(loc->hdr.uuid));		break;	default:		ERR("not implemented question id: %u", question);	}	return 0;}

/* * bucket_tree_insert_block -- (internal) inserts a new memory block *	into the container */static intbucket_tree_insert_block(struct block_container *bc, struct palloc_heap *heap,	struct memory_block m){	/*	 * Even though the memory block representation of an object uses	 * relatively large types in practise the entire memory block structure	 * needs to fit in a single 64 bit value - the type of the key in the	 * container tree.	 * Given those limitations a reasonable idea might be to make the	 * memory_block structure be the size of single uint64_t, which would	 * work for now, but if someday someone decides there's a need for	 * larger objects the current implementation would allow them to simply	 * replace this container instead of making little changes all over	 * the heap code.	 */	ASSERT(m.chunk_id < MAX_CHUNK);	ASSERT(m.zone_id < UINT16_MAX);	ASSERTne(m.size_idx, 0);	struct block_container_ctree *c = (struct block_container_ctree *)bc;#ifdef USE_VG_MEMCHECK	bucket_vg_mark_noaccess(heap, bc, m);#endif	uint64_t key = CHUNK_KEY_PACK(m.zone_id, m.chunk_id, m.block_off,				m.size_idx);	return ctree_insert(c->tree, key, 0);}

intmain(int argc, char *argv[]){	VMEM *vmp;	size_t i;	START(argc, argv, "vmem_pool_create_in_region");	if (argc > 1)		FATAL("usage: %s", argv[0]);	vmp = vmem_pool_create_in_region(mem_pool, VMEM_MIN_POOL);	if (vmp == NULL)		FATAL("!vmem_pool_create_in_region");	for (i = 0; i < TEST_ALLOCATIONS; ++i) {		allocs[i] = vmem_malloc(vmp, sizeof (int));		ASSERTne(allocs[i], NULL);		/* check that pointer came from mem_pool */		ASSERTrange(allocs[i], mem_pool, VMEM_MIN_POOL);	}	for (i = 0; i < TEST_ALLOCATIONS; ++i) {		vmem_free(vmp, allocs[i]);	}	vmem_pool_delete(vmp);	DONE(NULL);}