[ceph.git] / ceph / src / spdk / test / lib / blobfs / cache_ut / cache_ut.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 <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>

#include "spdk/blobfs.h"
#include "spdk/env.h"
#include "spdk/log.h"
#include "spdk/io_channel.h"
#include "spdk/barrier.h"

#include "spdk_cunit.h"
#include "lib/blob/bs_dev_common.c"
#include "lib/test_env.c"
#include "blobfs.c"
#include "tree.c"

struct spdk_filesystem *g_fs;
struct spdk_file *g_file;
int g_fserrno;

struct spdk_bs_dev g_dev;

struct ut_request {
	fs_request_fn fn;
	void *arg;
	volatile int done;
	int from_ut;
};

volatile struct ut_request *g_req = NULL;
volatile int g_phase = 0;

static void
send_request(fs_request_fn fn, void *arg)
{
	struct ut_request *req;

	req = calloc(1, sizeof(*req));
	assert(req != NULL);
	req->fn = fn;
	req->arg = arg;
	req->done = 0;
	req->from_ut = 0;
	g_req = req;
	spdk_mb();
	g_phase = !g_phase;
	spdk_mb();
}

static void
ut_send_request(fs_request_fn fn, void *arg)
{
	struct ut_request req;

	req.fn = fn;
	req.arg = arg;
	req.done = 0;
	req.from_ut = 1;
	g_req = &req;
	spdk_mb();
	g_phase = !g_phase;
	spdk_mb();
	while (req.done == 0)
		;
}

static void
fs_op_complete(void *ctx, int fserrno)
{
	g_fserrno = fserrno;
}

static void
fs_op_with_handle_complete(void *ctx, struct spdk_filesystem *fs, int fserrno)
{
	g_fs = fs;
	g_fserrno = fserrno;
}

static void
_fs_init(void *arg)
{
	g_fs = NULL;
	g_fserrno = -1;
	spdk_fs_init(&g_dev, send_request, fs_op_with_handle_complete, NULL);
	SPDK_CU_ASSERT_FATAL(g_fs != NULL);
	CU_ASSERT(g_fserrno == 0);
}

static void
_fs_unload(void *arg)
{
	g_fserrno = -1;
	spdk_fs_unload(g_fs, fs_op_complete, NULL);
	CU_ASSERT(g_fserrno == 0);
	g_fs = NULL;
}

static void
cache_write(void)
{
	uint64_t length;
	int rc;
	char buf[100];
	struct spdk_io_channel *channel;

	ut_send_request(_fs_init, NULL);

	spdk_allocate_thread();
	channel = spdk_fs_alloc_io_channel_sync(g_fs, SPDK_IO_PRIORITY_DEFAULT);

	rc = spdk_fs_open_file(g_fs, channel, "testfile", SPDK_BLOBFS_OPEN_CREATE, &g_file);
	CU_ASSERT(rc == 0);
	SPDK_CU_ASSERT_FATAL(g_file != NULL);

	length = (4 * 1024 * 1024);
	spdk_file_truncate(g_file, channel, length);

	spdk_file_write(g_file, channel, buf, 0, sizeof(buf));

	CU_ASSERT(spdk_file_get_length(g_file) == length);

	spdk_file_truncate(g_file, channel, sizeof(buf));

	spdk_file_close(g_file, channel);
	rc = spdk_fs_delete_file(g_fs, channel, "testfile");
	CU_ASSERT(rc == 0);

	rc = spdk_fs_delete_file(g_fs, channel, "testfile");
	CU_ASSERT(rc == -ENOENT);

	spdk_fs_free_io_channel(channel);
	spdk_free_thread();

	ut_send_request(_fs_unload, NULL);
}

static void
cache_append_no_cache(void)
{
	int rc;
	char buf[100];
	struct spdk_io_channel *channel;

	ut_send_request(_fs_init, NULL);

	spdk_allocate_thread();
	channel = spdk_fs_alloc_io_channel_sync(g_fs, SPDK_IO_PRIORITY_DEFAULT);

	rc = spdk_fs_open_file(g_fs, channel, "testfile", SPDK_BLOBFS_OPEN_CREATE, &g_file);
	CU_ASSERT(rc == 0);
	SPDK_CU_ASSERT_FATAL(g_file != NULL);

	spdk_file_write(g_file, channel, buf, 0 * sizeof(buf), sizeof(buf));
	CU_ASSERT(spdk_file_get_length(g_file) == 1 * sizeof(buf));
	spdk_file_write(g_file, channel, buf, 1 * sizeof(buf), sizeof(buf));
	CU_ASSERT(spdk_file_get_length(g_file) == 2 * sizeof(buf));
	spdk_file_sync(g_file, channel);
	cache_free_buffers(g_file);
	spdk_file_write(g_file, channel, buf, 2 * sizeof(buf), sizeof(buf));
	CU_ASSERT(spdk_file_get_length(g_file) == 3 * sizeof(buf));
	spdk_file_write(g_file, channel, buf, 3 * sizeof(buf), sizeof(buf));
	CU_ASSERT(spdk_file_get_length(g_file) == 4 * sizeof(buf));
	spdk_file_write(g_file, channel, buf, 4 * sizeof(buf), sizeof(buf));
	CU_ASSERT(spdk_file_get_length(g_file) == 5 * sizeof(buf));

	spdk_file_close(g_file, channel);
	rc = spdk_fs_delete_file(g_fs, channel, "testfile");
	CU_ASSERT(rc == 0);

	spdk_fs_free_io_channel(channel);
	spdk_free_thread();

	ut_send_request(_fs_unload, NULL);
}

static void
terminate_spdk_thread(void *arg)
{
	spdk_free_thread();
	pthread_exit(NULL);
}

static void *
spdk_thread(void *arg)
{
	struct ut_request *req;
	int phase = 0;
	spdk_allocate_thread();

	while (1) {
		spdk_mb();
		if (phase != g_phase) {
			req = (void *)g_req;
			req->fn(req->arg);
			req->done = 1;
			spdk_mb();
			if (!req->from_ut) {
				free(req);
			}
			phase = !phase;
		}
	}

	return NULL;
}

int main(int argc, char **argv)
{
	CU_pSuite	suite = NULL;
	pthread_t	spdk_tid;
	unsigned int	num_failures;

	if (CU_initialize_registry() != CUE_SUCCESS) {
		return CU_get_error();
	}

	suite = CU_add_suite("cache_ut", NULL, NULL);
	if (suite == NULL) {
		CU_cleanup_registry();
		return CU_get_error();
	}

	if (
		CU_add_test(suite, "write", cache_write) == NULL ||
		CU_add_test(suite, "append_no_cache", cache_append_no_cache) == NULL
	) {
		CU_cleanup_registry();
		return CU_get_error();
	}

	init_dev(&g_dev);
	pthread_create(&spdk_tid, NULL, spdk_thread, NULL);
	g_dev_buffer = calloc(1, DEV_BUFFER_SIZE);
	CU_basic_set_mode(CU_BRM_VERBOSE);
	CU_basic_run_tests();
	num_failures = CU_get_number_of_failures();
	CU_cleanup_registry();
	free(g_dev_buffer);
	send_request(terminate_spdk_thread, NULL);
	pthread_join(spdk_tid, NULL);
	return num_failures;
}
Commit	Line	Data
7c673cae FG	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 <stdlib.h>
	35	#include <unistd.h>
	36	#include <errno.h>
	37	#include <stdio.h>
	38	#include <stdint.h>
	39	#include <string.h>
	40	#include <stdbool.h>
	41
	42	#include "spdk/blobfs.h"
	43	#include "spdk/env.h"
	44	#include "spdk/log.h"
	45	#include "spdk/io_channel.h"
	46	#include "spdk/barrier.h"
	47
	48	#include "spdk_cunit.h"
	49	#include "lib/blob/bs_dev_common.c"
	50	#include "lib/test_env.c"
	51	#include "blobfs.c"
	52	#include "tree.c"
	53
	54	struct spdk_filesystem *g_fs;
	55	struct spdk_file *g_file;
	56	int g_fserrno;
	57
	58	struct spdk_bs_dev g_dev;
	59
	60	struct ut_request {
	61	fs_request_fn fn;
	62	void *arg;
	63	volatile int done;
	64	int from_ut;
65	};
66
67	volatile struct ut_request *g_req = NULL;
68	volatile int g_phase = 0;
69
70	static void
71	send_request(fs_request_fn fn, void *arg)
72	{
73	struct ut_request *req;
74
75	req = calloc(1, sizeof(*req));
76	assert(req != NULL);
77	req->fn = fn;
78	req->arg = arg;
79	req->done = 0;
80	req->from_ut = 0;
81	g_req = req;
82	spdk_mb();
83	g_phase = !g_phase;
84	spdk_mb();
85	}
86
87	static void
88	ut_send_request(fs_request_fn fn, void *arg)
89	{
90	struct ut_request req;
91
92	req.fn = fn;
93	req.arg = arg;
94	req.done = 0;
95	req.from_ut = 1;
96	g_req = &req;
97	spdk_mb();
98	g_phase = !g_phase;
99	spdk_mb();
100	while (req.done == 0)
101	;
102	}
103
104	static void
105	fs_op_complete(void *ctx, int fserrno)
106	{
107	g_fserrno = fserrno;
108	}
109
110	static void
111	fs_op_with_handle_complete(void ctx, struct spdk_filesystem fs, int fserrno)
112	{
113	g_fs = fs;
114	g_fserrno = fserrno;
115	}
116
117	static void
118	_fs_init(void *arg)
119	{
120	g_fs = NULL;
121	g_fserrno = -1;
122	spdk_fs_init(&g_dev, send_request, fs_op_with_handle_complete, NULL);
123	SPDK_CU_ASSERT_FATAL(g_fs != NULL);
124	CU_ASSERT(g_fserrno == 0);
125	}
126
127	static void
128	_fs_unload(void *arg)
129	{
130	g_fserrno = -1;
131	spdk_fs_unload(g_fs, fs_op_complete, NULL);
132	CU_ASSERT(g_fserrno == 0);
133	g_fs = NULL;
134	}
135
136	static void
137	cache_write(void)
138	{
139	uint64_t length;
140	int rc;
141	char buf[100];
142	struct spdk_io_channel *channel;
143
144	ut_send_request(_fs_init, NULL);
145
146	spdk_allocate_thread();
147	channel = spdk_fs_alloc_io_channel_sync(g_fs, SPDK_IO_PRIORITY_DEFAULT);
148
149	rc = spdk_fs_open_file(g_fs, channel, "testfile", SPDK_BLOBFS_OPEN_CREATE, &g_file);
150	CU_ASSERT(rc == 0);
151	SPDK_CU_ASSERT_FATAL(g_file != NULL);
152
153	length = (4 * 1024 * 1024);
154	spdk_file_truncate(g_file, channel, length);
155
156	spdk_file_write(g_file, channel, buf, 0, sizeof(buf));
157
158	CU_ASSERT(spdk_file_get_length(g_file) == length);
159
160	spdk_file_truncate(g_file, channel, sizeof(buf));
161
162	spdk_file_close(g_file, channel);
163	rc = spdk_fs_delete_file(g_fs, channel, "testfile");
164	CU_ASSERT(rc == 0);
165
166	rc = spdk_fs_delete_file(g_fs, channel, "testfile");
167	CU_ASSERT(rc == -ENOENT);
168
169	spdk_fs_free_io_channel(channel);
170	spdk_free_thread();
171
172	ut_send_request(_fs_unload, NULL);
173	}
174
175	static void
176	cache_append_no_cache(void)
177	{
178	int rc;
179	char buf[100];
180	struct spdk_io_channel *channel;
181
182	ut_send_request(_fs_init, NULL);
183
184	spdk_allocate_thread();
185	channel = spdk_fs_alloc_io_channel_sync(g_fs, SPDK_IO_PRIORITY_DEFAULT);
186
187	rc = spdk_fs_open_file(g_fs, channel, "testfile", SPDK_BLOBFS_OPEN_CREATE, &g_file);
188	CU_ASSERT(rc == 0);
189	SPDK_CU_ASSERT_FATAL(g_file != NULL);
190
191	spdk_file_write(g_file, channel, buf, 0 * sizeof(buf), sizeof(buf));
192	CU_ASSERT(spdk_file_get_length(g_file) == 1 * sizeof(buf));
193	spdk_file_write(g_file, channel, buf, 1 * sizeof(buf), sizeof(buf));
194	CU_ASSERT(spdk_file_get_length(g_file) == 2 * sizeof(buf));
195	spdk_file_sync(g_file, channel);
196	cache_free_buffers(g_file);
197	spdk_file_write(g_file, channel, buf, 2 * sizeof(buf), sizeof(buf));
198	CU_ASSERT(spdk_file_get_length(g_file) == 3 * sizeof(buf));
199	spdk_file_write(g_file, channel, buf, 3 * sizeof(buf), sizeof(buf));
200	CU_ASSERT(spdk_file_get_length(g_file) == 4 * sizeof(buf));
201	spdk_file_write(g_file, channel, buf, 4 * sizeof(buf), sizeof(buf));
202	CU_ASSERT(spdk_file_get_length(g_file) == 5 * sizeof(buf));
203
204	spdk_file_close(g_file, channel);
205	rc = spdk_fs_delete_file(g_fs, channel, "testfile");
206	CU_ASSERT(rc == 0);
207
208	spdk_fs_free_io_channel(channel);
209	spdk_free_thread();
210
211	ut_send_request(_fs_unload, NULL);
212	}
213
214	static void
215	terminate_spdk_thread(void *arg)
216	{
217	spdk_free_thread();
218	pthread_exit(NULL);
219	}
220
221	static void *
222	spdk_thread(void *arg)
223	{
224	struct ut_request *req;
225	int phase = 0;
226	spdk_allocate_thread();
227
228	while (1) {
229	spdk_mb();
230	if (phase != g_phase) {
231	req = (void *)g_req;
232	req->fn(req->arg);
233	req->done = 1;
234	spdk_mb();
235	if (!req->from_ut) {
236	free(req);
237	}
238	phase = !phase;
239	}
240	}
241
242	return NULL;
243	}
244
245	int main(int argc, char **argv)
246	{
247	CU_pSuite suite = NULL;
248	pthread_t spdk_tid;
249	unsigned int num_failures;
250
251	if (CU_initialize_registry() != CUE_SUCCESS) {
252	return CU_get_error();
253	}
254
255	suite = CU_add_suite("cache_ut", NULL, NULL);
256	if (suite == NULL) {
257	CU_cleanup_registry();
258	return CU_get_error();
259	}
260
261	if (
262	CU_add_test(suite, "write", cache_write) == NULL \|\|
263	CU_add_test(suite, "append_no_cache", cache_append_no_cache) == NULL
264	) {
265	CU_cleanup_registry();
266	return CU_get_error();
267	}
268
269	init_dev(&g_dev);
270	pthread_create(&spdk_tid, NULL, spdk_thread, NULL);
271	g_dev_buffer = calloc(1, DEV_BUFFER_SIZE);
272	CU_basic_set_mode(CU_BRM_VERBOSE);
273	CU_basic_run_tests();
274	num_failures = CU_get_number_of_failures();
275	CU_cleanup_registry();
276	free(g_dev_buffer);
277	send_request(terminate_spdk_thread, NULL);
278	pthread_join(spdk_tid, NULL);
279	return num_failures;
280	}