[ceph.git] / ceph / src / spdk / test / common / lib / test_env.c

/*-
 *   BSD LICENSE
 *
 *   Copyright (c) Intel Corporation.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "spdk/stdinc.h"

#include "spdk_internal/mock.h"

#include "spdk/env.h"
#include "spdk/queue.h"
#include "spdk/util.h"

static uint32_t g_ut_num_cores;
static bool *g_ut_cores;

void allocate_cores(uint32_t num_cores);
void free_cores(void);

DEFINE_STUB(spdk_process_is_primary, bool, (void), true)
DEFINE_STUB(spdk_memzone_lookup, void *, (const char *name), NULL)
DEFINE_STUB_V(spdk_pci_driver_register, (const char *name, struct spdk_pci_id *id_table,
		uint32_t flags));
DEFINE_STUB(spdk_pci_nvme_get_driver, struct spdk_pci_driver *, (void), NULL)
DEFINE_STUB(spdk_pci_ioat_get_driver, struct spdk_pci_driver *, (void), NULL)
DEFINE_STUB(spdk_pci_virtio_get_driver, struct spdk_pci_driver *, (void), NULL)

void
allocate_cores(uint32_t num_cores)
{
	uint32_t i;

	g_ut_num_cores = num_cores;

	g_ut_cores = calloc(num_cores, sizeof(bool));
	assert(g_ut_cores != NULL);

	for (i = 0; i < num_cores; i++) {
		g_ut_cores[i] = true;
	}
}

void
free_cores(void)
{
	free(g_ut_cores);
	g_ut_cores = NULL;
	g_ut_num_cores = 0;
}

static uint32_t
ut_get_next_core(uint32_t i)
{
	i++;

	while (i < g_ut_num_cores) {
		if (!g_ut_cores[i]) {
			i++;
			continue;
		}
		break;
	}

	if (i < g_ut_num_cores) {
		return i;
	} else {
		return UINT32_MAX;
	}
}

uint32_t
spdk_env_get_first_core(void)
{
	return ut_get_next_core(-1);
}

uint32_t
spdk_env_get_next_core(uint32_t prev_core)
{
	return ut_get_next_core(prev_core);
}

uint32_t
spdk_env_get_core_count(void)
{
	return g_ut_num_cores;
}

uint32_t
spdk_env_get_last_core(void)
{
	uint32_t i;
	uint32_t last_core = UINT32_MAX;

	SPDK_ENV_FOREACH_CORE(i) {
		last_core = i;
	}

	return last_core;
}

DEFINE_RETURN_MOCK(spdk_env_get_current_core, uint32_t);
uint32_t
spdk_env_get_current_core(void)
{
	HANDLE_RETURN_MOCK(spdk_env_get_current_core);

	return UINT32_MAX;
}

DEFINE_RETURN_MOCK(spdk_env_get_socket_id, uint32_t);
uint32_t
spdk_env_get_socket_id(uint32_t core)
{
	HANDLE_RETURN_MOCK(spdk_env_get_socket_id);

	return SPDK_ENV_SOCKET_ID_ANY;
}

/*
 * These mocks don't use the DEFINE_STUB macros because
 * their default implementation is more complex.
 */

DEFINE_RETURN_MOCK(spdk_memzone_reserve, void *);
void *
spdk_memzone_reserve(const char *name, size_t len, int socket_id, unsigned flags)
{
	HANDLE_RETURN_MOCK(spdk_memzone_reserve);

	return malloc(len);
}

DEFINE_RETURN_MOCK(spdk_memzone_reserve_aligned, void *);
void *
spdk_memzone_reserve_aligned(const char *name, size_t len, int socket_id,
			     unsigned flags, unsigned align)
{
	HANDLE_RETURN_MOCK(spdk_memzone_reserve_aligned);

	return malloc(len);
}

DEFINE_RETURN_MOCK(spdk_malloc, void *);
void *
spdk_malloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
{
	HANDLE_RETURN_MOCK(spdk_malloc);

	void *buf = NULL;

	if (align == 0) {
		align = 8;
	}

	if (posix_memalign(&buf, align, size)) {
		return NULL;
	}
	if (phys_addr) {
		*phys_addr = (uint64_t)buf;
	}

	return buf;
}

DEFINE_RETURN_MOCK(spdk_zmalloc, void *);
void *
spdk_zmalloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
{
	HANDLE_RETURN_MOCK(spdk_zmalloc);

	void *buf = spdk_malloc(size, align, phys_addr, -1, 1);

	if (buf != NULL) {
		memset(buf, 0, size);
	}
	return buf;
}

DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);
void *
spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)
{
	HANDLE_RETURN_MOCK(spdk_dma_malloc);

	return spdk_malloc(size, align, phys_addr, -1, 1);
}

DEFINE_RETURN_MOCK(spdk_realloc, void *);
void *
spdk_realloc(void *buf, size_t size, size_t align)
{
	HANDLE_RETURN_MOCK(spdk_realloc);

	return realloc(buf, size);
}

DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *);
void *
spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)
{
	HANDLE_RETURN_MOCK(spdk_dma_zmalloc);

	return spdk_zmalloc(size, align, phys_addr, -1, 1);
}

DEFINE_RETURN_MOCK(spdk_dma_malloc_socket, void *);
void *
spdk_dma_malloc_socket(size_t size, size_t align, uint64_t *phys_addr, int socket_id)
{
	HANDLE_RETURN_MOCK(spdk_dma_malloc_socket);

	return spdk_dma_malloc(size, align, phys_addr);
}

DEFINE_RETURN_MOCK(spdk_dma_zmalloc_socket, void *);
void *
spdk_dma_zmalloc_socket(size_t size, size_t align, uint64_t *phys_addr, int socket_id)
{
	HANDLE_RETURN_MOCK(spdk_dma_zmalloc_socket);

	return spdk_dma_zmalloc(size, align, phys_addr);
}

DEFINE_RETURN_MOCK(spdk_dma_realloc, void *);
void *
spdk_dma_realloc(void *buf, size_t size, size_t align, uint64_t *phys_addr)
{
	HANDLE_RETURN_MOCK(spdk_dma_realloc);

	return realloc(buf, size);
}

void
spdk_free(void *buf)
{
	/* fix for false-positives in *certain* static analysis tools. */
	assert((uintptr_t)buf != UINTPTR_MAX);
	free(buf);
}

void
spdk_dma_free(void *buf)
{
	return spdk_free(buf);
}

#ifndef UNIT_TEST_NO_VTOPHYS
DEFINE_RETURN_MOCK(spdk_vtophys, uint64_t);
uint64_t
spdk_vtophys(void *buf, uint64_t *size)
{
	HANDLE_RETURN_MOCK(spdk_vtophys);

	return (uintptr_t)buf;
}
#endif

void
spdk_memzone_dump(FILE *f)
{
	return;
}

DEFINE_RETURN_MOCK(spdk_memzone_free, int);
int
spdk_memzone_free(const char *name)
{
	HANDLE_RETURN_MOCK(spdk_memzone_free);

	return 0;
}

struct test_mempool {
	size_t	count;
	size_t	ele_size;
};

DEFINE_RETURN_MOCK(spdk_mempool_create, struct spdk_mempool *);
struct spdk_mempool *
spdk_mempool_create(const char *name, size_t count,
		    size_t ele_size, size_t cache_size, int socket_id)
{
	struct test_mempool *mp;

	HANDLE_RETURN_MOCK(spdk_mempool_create);

	mp = calloc(1, sizeof(*mp));
	if (mp == NULL) {
		return NULL;
	}

	mp->count = count;
	mp->ele_size = ele_size;

	return (struct spdk_mempool *)mp;
}

void
spdk_mempool_free(struct spdk_mempool *_mp)
{
	struct test_mempool *mp = (struct test_mempool *)_mp;

	free(mp);
}

DEFINE_RETURN_MOCK(spdk_mempool_get, void *);
void *
spdk_mempool_get(struct spdk_mempool *_mp)
{
	struct test_mempool *mp = (struct test_mempool *)_mp;
	size_t ele_size = 0x10000;
	void *buf;

	HANDLE_RETURN_MOCK(spdk_mempool_get);

	if (mp && mp->count == 0) {
		return NULL;
	}

	if (mp) {
		ele_size = mp->ele_size;
	}

	if (posix_memalign(&buf, 64, spdk_align32pow2(ele_size))) {
		return NULL;
	} else {
		if (mp) {
			mp->count--;
		}
		return buf;
	}
}

int
spdk_mempool_get_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
{
	for (size_t i = 0; i < count; i++) {
		ele_arr[i] = spdk_mempool_get(mp);
		if (ele_arr[i] == NULL) {
			return -1;
		}
	}
	return 0;
}

void
spdk_mempool_put(struct spdk_mempool *_mp, void *ele)
{
	struct test_mempool *mp = (struct test_mempool *)_mp;

	if (mp) {
		mp->count++;
	}
	free(ele);
}

void
spdk_mempool_put_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count)
{
	for (size_t i = 0; i < count; i++) {
		spdk_mempool_put(mp, ele_arr[i]);
	}
}

DEFINE_RETURN_MOCK(spdk_mempool_count, size_t);
size_t
spdk_mempool_count(const struct spdk_mempool *_mp)
{
	struct test_mempool *mp = (struct test_mempool *)_mp;

	HANDLE_RETURN_MOCK(spdk_mempool_count);

	if (mp) {
		return mp->count;
	} else {
		return 1024;
	}
}

struct spdk_ring_ele {
	void *ele;
	TAILQ_ENTRY(spdk_ring_ele) link;
};

struct spdk_ring {
	TAILQ_HEAD(, spdk_ring_ele) elements;
	pthread_mutex_t lock;
	size_t count;
};

DEFINE_RETURN_MOCK(spdk_ring_create, struct spdk_ring *);
struct spdk_ring *
spdk_ring_create(enum spdk_ring_type type, size_t count, int socket_id)
{
	struct spdk_ring *ring;

	HANDLE_RETURN_MOCK(spdk_ring_create);

	ring = calloc(1, sizeof(*ring));
	if (!ring) {
		return NULL;
	}

	if (pthread_mutex_init(&ring->lock, NULL)) {
		free(ring);
		return NULL;
	}

	TAILQ_INIT(&ring->elements);
	return ring;
}

void
spdk_ring_free(struct spdk_ring *ring)
{
	struct spdk_ring_ele *ele, *tmp;

	if (!ring) {
		return;
	}

	TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
		free(ele);
	}

	pthread_mutex_destroy(&ring->lock);
	free(ring);
}

DEFINE_RETURN_MOCK(spdk_ring_enqueue, size_t);
size_t
spdk_ring_enqueue(struct spdk_ring *ring, void **objs, size_t count,
		  size_t *free_space)
{
	struct spdk_ring_ele *ele;
	size_t i;

	HANDLE_RETURN_MOCK(spdk_ring_enqueue);

	pthread_mutex_lock(&ring->lock);

	for (i = 0; i < count; i++) {
		ele = calloc(1, sizeof(*ele));
		if (!ele) {
			break;
		}

		ele->ele = objs[i];
		TAILQ_INSERT_TAIL(&ring->elements, ele, link);
		ring->count++;
	}

	pthread_mutex_unlock(&ring->lock);
	return i;
}

DEFINE_RETURN_MOCK(spdk_ring_dequeue, size_t);
size_t
spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count)
{
	struct spdk_ring_ele *ele, *tmp;
	size_t i = 0;

	HANDLE_RETURN_MOCK(spdk_ring_dequeue);

	if (count == 0) {
		return 0;
	}

	pthread_mutex_lock(&ring->lock);

	TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
		TAILQ_REMOVE(&ring->elements, ele, link);
		ring->count--;
		objs[i] = ele->ele;
		free(ele);
		i++;
		if (i >= count) {
			break;
		}
	}

	pthread_mutex_unlock(&ring->lock);
	return i;

}


DEFINE_RETURN_MOCK(spdk_ring_count, size_t);
size_t
spdk_ring_count(struct spdk_ring *ring)
{
	HANDLE_RETURN_MOCK(spdk_ring_count);
	return ring->count;
}

DEFINE_RETURN_MOCK(spdk_get_ticks, uint64_t);
uint64_t
spdk_get_ticks(void)
{
	HANDLE_RETURN_MOCK(spdk_get_ticks);

	return ut_spdk_get_ticks;
}

DEFINE_RETURN_MOCK(spdk_get_ticks_hz, uint64_t);
uint64_t
spdk_get_ticks_hz(void)
{
	HANDLE_RETURN_MOCK(spdk_get_ticks_hz);

	return 1000000;
}

void
spdk_delay_us(unsigned int us)
{
	/* spdk_get_ticks_hz is 1000000, meaning 1 tick per us. */
	ut_spdk_get_ticks += us;
}

#ifndef UNIT_TEST_NO_PCI_ADDR
DEFINE_RETURN_MOCK(spdk_pci_addr_parse, int);
int
spdk_pci_addr_parse(struct spdk_pci_addr *addr, const char *bdf)
{
	unsigned domain, bus, dev, func;

	HANDLE_RETURN_MOCK(spdk_pci_addr_parse);

	if (addr == NULL || bdf == NULL) {
		return -EINVAL;
	}

	if ((sscanf(bdf, "%x:%x:%x.%x", &domain, &bus, &dev, &func) == 4) ||
	    (sscanf(bdf, "%x.%x.%x.%x", &domain, &bus, &dev, &func) == 4)) {
		/* Matched a full address - all variables are initialized */
	} else if (sscanf(bdf, "%x:%x:%x", &domain, &bus, &dev) == 3) {
		func = 0;
	} else if ((sscanf(bdf, "%x:%x.%x", &bus, &dev, &func) == 3) ||
		   (sscanf(bdf, "%x.%x.%x", &bus, &dev, &func) == 3)) {
		domain = 0;
	} else if ((sscanf(bdf, "%x:%x", &bus, &dev) == 2) ||
		   (sscanf(bdf, "%x.%x", &bus, &dev) == 2)) {
		domain = 0;
		func = 0;
	} else {
		return -EINVAL;
	}

	if (bus > 0xFF || dev > 0x1F || func > 7) {
		return -EINVAL;
	}

	addr->domain = domain;
	addr->bus = bus;
	addr->dev = dev;
	addr->func = func;

	return 0;
}

DEFINE_RETURN_MOCK(spdk_pci_addr_fmt, int);
int
spdk_pci_addr_fmt(char *bdf, size_t sz, const struct spdk_pci_addr *addr)
{
	int rc;

	HANDLE_RETURN_MOCK(spdk_pci_addr_fmt);

	rc = snprintf(bdf, sz, "%04x:%02x:%02x.%x",
		      addr->domain, addr->bus,
		      addr->dev, addr->func);

	if (rc > 0 && (size_t)rc < sz) {
		return 0;
	}

	return -1;
}

DEFINE_RETURN_MOCK(spdk_pci_addr_compare, int);
int
spdk_pci_addr_compare(const struct spdk_pci_addr *a1, const struct spdk_pci_addr *a2)
{
	HANDLE_RETURN_MOCK(spdk_pci_addr_compare);

	if (a1->domain > a2->domain) {
		return 1;
	} else if (a1->domain < a2->domain) {
		return -1;
	} else if (a1->bus > a2->bus) {
		return 1;
	} else if (a1->bus < a2->bus) {
		return -1;
	} else if (a1->dev > a2->dev) {
		return 1;
	} else if (a1->dev < a2->dev) {
		return -1;
	} else if (a1->func > a2->func) {
		return 1;
	} else if (a1->func < a2->func) {
		return -1;
	}

	return 0;
}
#endif
Commit	Line	Data
11fdf7f2 TL	1	/*-
	2	* BSD LICENSE
	3	*
	4	* Copyright (c) Intel Corporation.
	5	* All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* * Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* * Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in
	15	* the documentation and/or other materials provided with the
	16	* distribution.
	17	* * Neither the name of Intel Corporation nor the names of its
	18	* contributors may be used to endorse or promote products derived
	19	* from this software without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	22	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	23	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	24	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	25	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	26	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	27	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	28	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	29	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	30	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	31	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	32	*/
	33
	34	#include "spdk/stdinc.h"
	35
	36	#include "spdk_internal/mock.h"
	37
	38	#include "spdk/env.h"
	39	#include "spdk/queue.h"
9f95a23c	40	#include "spdk/util.h"
11fdf7f2	41
f67539c2 TL	42	static uint32_t g_ut_num_cores;
	43	static bool *g_ut_cores;
	44
	45	void allocate_cores(uint32_t num_cores);
	46	void free_cores(void);
	47
11fdf7f2 TL	48	DEFINE_STUB(spdk_process_is_primary, bool, (void), true)
11fdf7f2 TL	49	DEFINE_STUB(spdk_memzone_lookup, void , (const char name), NULL)
f67539c2 TL	50	DEFINE_STUB_V(spdk_pci_driver_register, (const char name, struct spdk_pci_id id_table,
f67539c2 TL	51	uint32_t flags));
9f95a23c TL	52	DEFINE_STUB(spdk_pci_nvme_get_driver, struct spdk_pci_driver *, (void), NULL)
	53	DEFINE_STUB(spdk_pci_ioat_get_driver, struct spdk_pci_driver *, (void), NULL)
	54	DEFINE_STUB(spdk_pci_virtio_get_driver, struct spdk_pci_driver *, (void), NULL)
11fdf7f2	55
f67539c2 TL	56	void
	57	allocate_cores(uint32_t num_cores)
	58	{
	59	uint32_t i;
	60
	61	g_ut_num_cores = num_cores;
	62
	63	g_ut_cores = calloc(num_cores, sizeof(bool));
	64	assert(g_ut_cores != NULL);
	65
	66	for (i = 0; i < num_cores; i++) {
	67	g_ut_cores[i] = true;
	68	}
	69	}
	70
	71	void
	72	free_cores(void)
	73	{
	74	free(g_ut_cores);
	75	g_ut_cores = NULL;
	76	g_ut_num_cores = 0;
	77	}
	78
	79	static uint32_t
	80	ut_get_next_core(uint32_t i)
	81	{
	82	i++;
	83
	84	while (i < g_ut_num_cores) {
	85	if (!g_ut_cores[i]) {
	86	i++;
	87	continue;
	88	}
	89	break;
	90	}
	91
	92	if (i < g_ut_num_cores) {
	93	return i;
	94	} else {
	95	return UINT32_MAX;
	96	}
	97	}
	98
	99	uint32_t
	100	spdk_env_get_first_core(void)
	101	{
	102	return ut_get_next_core(-1);
	103	}
	104
	105	uint32_t
	106	spdk_env_get_next_core(uint32_t prev_core)
	107	{
	108	return ut_get_next_core(prev_core);
	109	}
	110
	111	uint32_t
	112	spdk_env_get_core_count(void)
	113	{
	114	return g_ut_num_cores;
	115	}
	116
	117	uint32_t
	118	spdk_env_get_last_core(void)
	119	{
120	uint32_t i;
121	uint32_t last_core = UINT32_MAX;
122
123	SPDK_ENV_FOREACH_CORE(i) {
124	last_core = i;
125	}
126
127	return last_core;
128	}
129
130	DEFINE_RETURN_MOCK(spdk_env_get_current_core, uint32_t);
131	uint32_t
132	spdk_env_get_current_core(void)
133	{
134	HANDLE_RETURN_MOCK(spdk_env_get_current_core);
135
136	return UINT32_MAX;
137	}
138
139	DEFINE_RETURN_MOCK(spdk_env_get_socket_id, uint32_t);
140	uint32_t
141	spdk_env_get_socket_id(uint32_t core)
142	{
143	HANDLE_RETURN_MOCK(spdk_env_get_socket_id);
144
145	return SPDK_ENV_SOCKET_ID_ANY;
146	}
147
11fdf7f2 TL	148	/*
	149	* These mocks don't use the DEFINE_STUB macros because
	150	* their default implementation is more complex.
	151	*/
	152
	153	DEFINE_RETURN_MOCK(spdk_memzone_reserve, void *);
	154	void *
	155	spdk_memzone_reserve(const char *name, size_t len, int socket_id, unsigned flags)
	156	{
	157	HANDLE_RETURN_MOCK(spdk_memzone_reserve);
	158
	159	return malloc(len);
	160	}
	161
	162	DEFINE_RETURN_MOCK(spdk_memzone_reserve_aligned, void *);
	163	void *
	164	spdk_memzone_reserve_aligned(const char *name, size_t len, int socket_id,
	165	unsigned flags, unsigned align)
	166	{
	167	HANDLE_RETURN_MOCK(spdk_memzone_reserve_aligned);
	168
	169	return malloc(len);
	170	}
	171
	172	DEFINE_RETURN_MOCK(spdk_malloc, void *);
	173	void *
	174	spdk_malloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
	175	{
	176	HANDLE_RETURN_MOCK(spdk_malloc);
	177
	178	void *buf = NULL;
9f95a23c TL	179
	180	if (align == 0) {
	181	align = 8;
	182	}
	183
11fdf7f2 TL	184	if (posix_memalign(&buf, align, size)) {
	185	return NULL;
	186	}
	187	if (phys_addr) {
	188	*phys_addr = (uint64_t)buf;
	189	}
	190
	191	return buf;
	192	}
	193
	194	DEFINE_RETURN_MOCK(spdk_zmalloc, void *);
	195	void *
	196	spdk_zmalloc(size_t size, size_t align, uint64_t *phys_addr, int socket_id, uint32_t flags)
	197	{
	198	HANDLE_RETURN_MOCK(spdk_zmalloc);
	199
	200	void *buf = spdk_malloc(size, align, phys_addr, -1, 1);
	201
	202	if (buf != NULL) {
	203	memset(buf, 0, size);
	204	}
	205	return buf;
	206	}
	207
	208	DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);
	209	void *
	210	spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)
	211	{
	212	HANDLE_RETURN_MOCK(spdk_dma_malloc);
	213
	214	return spdk_malloc(size, align, phys_addr, -1, 1);
	215	}
	216
9f95a23c TL	217	DEFINE_RETURN_MOCK(spdk_realloc, void *);
	218	void *
	219	spdk_realloc(void *buf, size_t size, size_t align)
	220	{
	221	HANDLE_RETURN_MOCK(spdk_realloc);
	222
	223	return realloc(buf, size);
	224	}
	225
11fdf7f2 TL	226	DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *);
	227	void *
	228	spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)
	229	{
	230	HANDLE_RETURN_MOCK(spdk_dma_zmalloc);
	231
	232	return spdk_zmalloc(size, align, phys_addr, -1, 1);
	233	}
	234
	235	DEFINE_RETURN_MOCK(spdk_dma_malloc_socket, void *);
	236	void *
	237	spdk_dma_malloc_socket(size_t size, size_t align, uint64_t *phys_addr, int socket_id)
	238	{
	239	HANDLE_RETURN_MOCK(spdk_dma_malloc_socket);
	240
	241	return spdk_dma_malloc(size, align, phys_addr);
	242	}
	243
	244	DEFINE_RETURN_MOCK(spdk_dma_zmalloc_socket, void *);
	245	void *
	246	spdk_dma_zmalloc_socket(size_t size, size_t align, uint64_t *phys_addr, int socket_id)
	247	{
	248	HANDLE_RETURN_MOCK(spdk_dma_zmalloc_socket);
	249
	250	return spdk_dma_zmalloc(size, align, phys_addr);
	251	}
	252
	253	DEFINE_RETURN_MOCK(spdk_dma_realloc, void *);
	254	void *
	255	spdk_dma_realloc(void buf, size_t size, size_t align, uint64_t phys_addr)
	256	{
	257	HANDLE_RETURN_MOCK(spdk_dma_realloc);
	258
	259	return realloc(buf, size);
	260	}
	261
	262	void
	263	spdk_free(void *buf)
	264	{
9f95a23c TL	265	/* fix for false-positives in certain static analysis tools. */
9f95a23c TL	266	assert((uintptr_t)buf != UINTPTR_MAX);
11fdf7f2 TL	267	free(buf);
	268	}
	269
	270	void
	271	spdk_dma_free(void *buf)
	272	{
	273	return spdk_free(buf);
	274	}
	275
9f95a23c	276	#ifndef UNIT_TEST_NO_VTOPHYS
11fdf7f2 TL	277	DEFINE_RETURN_MOCK(spdk_vtophys, uint64_t);
11fdf7f2 TL	278	uint64_t
9f95a23c	279	spdk_vtophys(void buf, uint64_t size)
11fdf7f2 TL	280	{
	281	HANDLE_RETURN_MOCK(spdk_vtophys);
	282
	283	return (uintptr_t)buf;
	284	}
9f95a23c	285	#endif
11fdf7f2 TL	286
	287	void
	288	spdk_memzone_dump(FILE *f)
	289	{
	290	return;
	291	}
	292
	293	DEFINE_RETURN_MOCK(spdk_memzone_free, int);
	294	int
	295	spdk_memzone_free(const char *name)
	296	{
	297	HANDLE_RETURN_MOCK(spdk_memzone_free);
	298
	299	return 0;
	300	}
	301
	302	struct test_mempool {
	303	size_t count;
9f95a23c	304	size_t ele_size;
11fdf7f2 TL	305	};
	306
	307	DEFINE_RETURN_MOCK(spdk_mempool_create, struct spdk_mempool *);
	308	struct spdk_mempool *
	309	spdk_mempool_create(const char *name, size_t count,
	310	size_t ele_size, size_t cache_size, int socket_id)
	311	{
	312	struct test_mempool *mp;
	313
	314	HANDLE_RETURN_MOCK(spdk_mempool_create);
	315
	316	mp = calloc(1, sizeof(*mp));
	317	if (mp == NULL) {
	318	return NULL;
	319	}
	320
	321	mp->count = count;
9f95a23c	322	mp->ele_size = ele_size;
11fdf7f2 TL	323
	324	return (struct spdk_mempool *)mp;
	325	}
	326
	327	void
	328	spdk_mempool_free(struct spdk_mempool *_mp)
	329	{
	330	struct test_mempool mp = (struct test_mempool )_mp;
	331
	332	free(mp);
	333	}
	334
	335	DEFINE_RETURN_MOCK(spdk_mempool_get, void *);
	336	void *
	337	spdk_mempool_get(struct spdk_mempool *_mp)
	338	{
	339	struct test_mempool mp = (struct test_mempool )_mp;
9f95a23c	340	size_t ele_size = 0x10000;
11fdf7f2 TL	341	void *buf;
	342
	343	HANDLE_RETURN_MOCK(spdk_mempool_get);
	344
	345	if (mp && mp->count == 0) {
	346	return NULL;
	347	}
	348
9f95a23c TL	349	if (mp) {
	350	ele_size = mp->ele_size;
	351	}
	352
	353	if (posix_memalign(&buf, 64, spdk_align32pow2(ele_size))) {
11fdf7f2 TL	354	return NULL;
	355	} else {
	356	if (mp) {
	357	mp->count--;
	358	}
	359	return buf;
	360	}
	361	}
	362
	363	int
	364	spdk_mempool_get_bulk(struct spdk_mempool mp, void *ele_arr, size_t count)
	365	{
	366	for (size_t i = 0; i < count; i++) {
	367	ele_arr[i] = spdk_mempool_get(mp);
	368	if (ele_arr[i] == NULL) {
	369	return -1;
	370	}
	371	}
	372	return 0;
	373	}
	374
	375	void
	376	spdk_mempool_put(struct spdk_mempool _mp, void ele)
	377	{
	378	struct test_mempool mp = (struct test_mempool )_mp;
	379
	380	if (mp) {
	381	mp->count++;
	382	}
	383	free(ele);
	384	}
	385
	386	void
	387	spdk_mempool_put_bulk(struct spdk_mempool mp, void *ele_arr, size_t count)
	388	{
	389	for (size_t i = 0; i < count; i++) {
	390	spdk_mempool_put(mp, ele_arr[i]);
	391	}
	392	}
	393
	394	DEFINE_RETURN_MOCK(spdk_mempool_count, size_t);
	395	size_t
	396	spdk_mempool_count(const struct spdk_mempool *_mp)
	397	{
	398	struct test_mempool mp = (struct test_mempool )_mp;
	399
	400	HANDLE_RETURN_MOCK(spdk_mempool_count);
	401
	402	if (mp) {
	403	return mp->count;
	404	} else {
	405	return 1024;
	406	}
	407	}
	408
	409	struct spdk_ring_ele {
	410	void *ele;
	411	TAILQ_ENTRY(spdk_ring_ele) link;
	412	};
	413
	414	struct spdk_ring {
	415	TAILQ_HEAD(, spdk_ring_ele) elements;
9f95a23c TL	416	pthread_mutex_t lock;
9f95a23c TL	417	size_t count;
11fdf7f2 TL	418	};
	419
	420	DEFINE_RETURN_MOCK(spdk_ring_create, struct spdk_ring *);
	421	struct spdk_ring *
	422	spdk_ring_create(enum spdk_ring_type type, size_t count, int socket_id)
	423	{
	424	struct spdk_ring *ring;
	425
	426	HANDLE_RETURN_MOCK(spdk_ring_create);
	427
	428	ring = calloc(1, sizeof(*ring));
9f95a23c TL	429	if (!ring) {
	430	return NULL;
	431	}
	432
	433	if (pthread_mutex_init(&ring->lock, NULL)) {
	434	free(ring);
	435	return NULL;
11fdf7f2 TL	436	}
11fdf7f2 TL	437
9f95a23c	438	TAILQ_INIT(&ring->elements);
11fdf7f2 TL	439	return ring;
	440	}
	441
	442	void
	443	spdk_ring_free(struct spdk_ring *ring)
	444	{
9f95a23c TL	445	struct spdk_ring_ele ele, tmp;
	446
	447	if (!ring) {
	448	return;
	449	}
	450
	451	TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
	452	free(ele);
	453	}
	454
	455	pthread_mutex_destroy(&ring->lock);
11fdf7f2 TL	456	free(ring);
	457	}
	458
	459	DEFINE_RETURN_MOCK(spdk_ring_enqueue, size_t);
	460	size_t
9f95a23c TL	461	spdk_ring_enqueue(struct spdk_ring ring, void *objs, size_t count,
9f95a23c TL	462	size_t *free_space)
11fdf7f2 TL	463	{
	464	struct spdk_ring_ele *ele;
	465	size_t i;
	466
	467	HANDLE_RETURN_MOCK(spdk_ring_enqueue);
	468
9f95a23c TL	469	pthread_mutex_lock(&ring->lock);
9f95a23c TL	470
11fdf7f2 TL	471	for (i = 0; i < count; i++) {
	472	ele = calloc(1, sizeof(*ele));
	473	if (!ele) {
	474	break;
	475	}
	476
	477	ele->ele = objs[i];
	478	TAILQ_INSERT_TAIL(&ring->elements, ele, link);
9f95a23c	479	ring->count++;
11fdf7f2 TL	480	}
11fdf7f2 TL	481
9f95a23c	482	pthread_mutex_unlock(&ring->lock);
11fdf7f2 TL	483	return i;
	484	}
	485
	486	DEFINE_RETURN_MOCK(spdk_ring_dequeue, size_t);
	487	size_t
	488	spdk_ring_dequeue(struct spdk_ring ring, void *objs, size_t count)
	489	{
	490	struct spdk_ring_ele ele, tmp;
	491	size_t i = 0;
	492
	493	HANDLE_RETURN_MOCK(spdk_ring_dequeue);
	494
	495	if (count == 0) {
	496	return 0;
	497	}
	498
9f95a23c TL	499	pthread_mutex_lock(&ring->lock);
9f95a23c TL	500
11fdf7f2 TL	501	TAILQ_FOREACH_SAFE(ele, &ring->elements, link, tmp) {
11fdf7f2 TL	502	TAILQ_REMOVE(&ring->elements, ele, link);
9f95a23c	503	ring->count--;
11fdf7f2 TL	504	objs[i] = ele->ele;
	505	free(ele);
	506	i++;
	507	if (i >= count) {
	508	break;
	509	}
	510	}
	511
9f95a23c	512	pthread_mutex_unlock(&ring->lock);
11fdf7f2 TL	513	return i;
	514
	515	}
	516
9f95a23c TL	517
	518	DEFINE_RETURN_MOCK(spdk_ring_count, size_t);
	519	size_t
	520	spdk_ring_count(struct spdk_ring *ring)
	521	{
	522	HANDLE_RETURN_MOCK(spdk_ring_count);
	523	return ring->count;
	524	}
	525
11fdf7f2 TL	526	DEFINE_RETURN_MOCK(spdk_get_ticks, uint64_t);
	527	uint64_t
	528	spdk_get_ticks(void)
	529	{
	530	HANDLE_RETURN_MOCK(spdk_get_ticks);
	531
	532	return ut_spdk_get_ticks;
	533	}
	534
	535	DEFINE_RETURN_MOCK(spdk_get_ticks_hz, uint64_t);
	536	uint64_t
	537	spdk_get_ticks_hz(void)
	538	{
	539	HANDLE_RETURN_MOCK(spdk_get_ticks_hz);
	540
	541	return 1000000;
	542	}
	543
	544	void
	545	spdk_delay_us(unsigned int us)
	546	{
	547	/* spdk_get_ticks_hz is 1000000, meaning 1 tick per us. */
	548	ut_spdk_get_ticks += us;
	549	}
	550
9f95a23c	551	#ifndef UNIT_TEST_NO_PCI_ADDR
11fdf7f2 TL	552	DEFINE_RETURN_MOCK(spdk_pci_addr_parse, int);
	553	int
	554	spdk_pci_addr_parse(struct spdk_pci_addr addr, const char bdf)
	555	{
	556	unsigned domain, bus, dev, func;
	557
	558	HANDLE_RETURN_MOCK(spdk_pci_addr_parse);
	559
	560	if (addr == NULL \|\| bdf == NULL) {
	561	return -EINVAL;
	562	}
	563
	564	if ((sscanf(bdf, "%x:%x:%x.%x", &domain, &bus, &dev, &func) == 4) \|\|
	565	(sscanf(bdf, "%x.%x.%x.%x", &domain, &bus, &dev, &func) == 4)) {
	566	/* Matched a full address - all variables are initialized */
	567	} else if (sscanf(bdf, "%x:%x:%x", &domain, &bus, &dev) == 3) {
	568	func = 0;
	569	} else if ((sscanf(bdf, "%x:%x.%x", &bus, &dev, &func) == 3) \|\|
	570	(sscanf(bdf, "%x.%x.%x", &bus, &dev, &func) == 3)) {
	571	domain = 0;
	572	} else if ((sscanf(bdf, "%x:%x", &bus, &dev) == 2) \|\|
	573	(sscanf(bdf, "%x.%x", &bus, &dev) == 2)) {
	574	domain = 0;
	575	func = 0;
	576	} else {
	577	return -EINVAL;
	578	}
	579
	580	if (bus > 0xFF \|\| dev > 0x1F \|\| func > 7) {
	581	return -EINVAL;
	582	}
	583
	584	addr->domain = domain;
	585	addr->bus = bus;
	586	addr->dev = dev;
	587	addr->func = func;
	588
	589	return 0;
	590	}
	591
	592	DEFINE_RETURN_MOCK(spdk_pci_addr_fmt, int);
	593	int
	594	spdk_pci_addr_fmt(char bdf, size_t sz, const struct spdk_pci_addr addr)
	595	{
	596	int rc;
	597
	598	HANDLE_RETURN_MOCK(spdk_pci_addr_fmt);
	599
	600	rc = snprintf(bdf, sz, "%04x:%02x:%02x.%x",
	601	addr->domain, addr->bus,
	602	addr->dev, addr->func);
	603
	604	if (rc > 0 && (size_t)rc < sz) {
	605	return 0;
	606	}
	607
	608	return -1;
	609	}
	610
	611	DEFINE_RETURN_MOCK(spdk_pci_addr_compare, int);
	612	int
	613	spdk_pci_addr_compare(const struct spdk_pci_addr a1, const struct spdk_pci_addr a2)
	614	{
	615	HANDLE_RETURN_MOCK(spdk_pci_addr_compare);
616
617	if (a1->domain > a2->domain) {
618	return 1;
619	} else if (a1->domain < a2->domain) {
620	return -1;
621	} else if (a1->bus > a2->bus) {
622	return 1;
623	} else if (a1->bus < a2->bus) {
624	return -1;
625	} else if (a1->dev > a2->dev) {
626	return 1;
627	} else if (a1->dev < a2->dev) {
628	return -1;
629	} else if (a1->func > a2->func) {
630	return 1;
631	} else if (a1->func < a2->func) {
632	return -1;
633	}
634
635	return 0;
636	}
9f95a23c	637	#endif