[deliverable/linux.git] / tools / usb / ffs-aio-example / simple / device_app / aio_simple.c

/*
 * This is free and unencumbered software released into the public domain.
 *
 * Anyone is free to copy, modify, publish, use, compile, sell, or
 * distribute this software, either in source code form or as a compiled
 * binary, for any purpose, commercial or non-commercial, and by any
 * means.
 *
 * In jurisdictions that recognize copyright laws, the author or authors
 * of this software dedicate any and all copyright interest in the
 * software to the public domain. We make this dedication for the benefit
 * of the public at large and to the detriment of our heirs and
 * successors. We intend this dedication to be an overt act of
 * relinquishment in perpetuity of all present and future rights to this
 * software under copyright law.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * For more information, please refer to <http://unlicense.org/>
 */

#define _BSD_SOURCE /* for endian.h */

#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/poll.h>
#include <unistd.h>
#include <stdbool.h>
#include <sys/eventfd.h>

#include "libaio.h"
#define IOCB_FLAG_RESFD         (1 << 0)

#include <linux/usb/functionfs.h>

#define BUF_LEN		8192

/******************** Descriptors and Strings *******************************/

static const struct {
	struct usb_functionfs_descs_head_v2 header;
	__le32 fs_count;
	__le32 hs_count;
	struct {
		struct usb_interface_descriptor intf;
		struct usb_endpoint_descriptor_no_audio bulk_sink;
		struct usb_endpoint_descriptor_no_audio bulk_source;
	} __attribute__ ((__packed__)) fs_descs, hs_descs;
} __attribute__ ((__packed__)) descriptors = {
	.header = {
		.magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),
		.flags = htole32(FUNCTIONFS_HAS_FS_DESC |
				     FUNCTIONFS_HAS_HS_DESC),
		.length = htole32(sizeof(descriptors)),
	},
	.fs_count = htole32(3),
	.fs_descs = {
		.intf = {
			.bLength = sizeof(descriptors.fs_descs.intf),
			.bDescriptorType = USB_DT_INTERFACE,
			.bNumEndpoints = 2,
			.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
			.iInterface = 1,
		},
		.bulk_sink = {
			.bLength = sizeof(descriptors.fs_descs.bulk_sink),
			.bDescriptorType = USB_DT_ENDPOINT,
			.bEndpointAddress = 1 | USB_DIR_IN,
			.bmAttributes = USB_ENDPOINT_XFER_BULK,
		},
		.bulk_source = {
			.bLength = sizeof(descriptors.fs_descs.bulk_source),
			.bDescriptorType = USB_DT_ENDPOINT,
			.bEndpointAddress = 2 | USB_DIR_OUT,
			.bmAttributes = USB_ENDPOINT_XFER_BULK,
		},
	},
	.hs_count = htole32(3),
	.hs_descs = {
		.intf = {
			.bLength = sizeof(descriptors.hs_descs.intf),
			.bDescriptorType = USB_DT_INTERFACE,
			.bNumEndpoints = 2,
			.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
			.iInterface = 1,
		},
		.bulk_sink = {
			.bLength = sizeof(descriptors.hs_descs.bulk_sink),
			.bDescriptorType = USB_DT_ENDPOINT,
			.bEndpointAddress = 1 | USB_DIR_IN,
			.bmAttributes = USB_ENDPOINT_XFER_BULK,
		},
		.bulk_source = {
			.bLength = sizeof(descriptors.hs_descs.bulk_source),
			.bDescriptorType = USB_DT_ENDPOINT,
			.bEndpointAddress = 2 | USB_DIR_OUT,
			.bmAttributes = USB_ENDPOINT_XFER_BULK,
		},
	},
};

#define STR_INTERFACE "AIO Test"

static const struct {
	struct usb_functionfs_strings_head header;
	struct {
		__le16 code;
		const char str1[sizeof(STR_INTERFACE)];
	} __attribute__ ((__packed__)) lang0;
} __attribute__ ((__packed__)) strings = {
	.header = {
		.magic = htole32(FUNCTIONFS_STRINGS_MAGIC),
		.length = htole32(sizeof(strings)),
		.str_count = htole32(1),
		.lang_count = htole32(1),
	},
	.lang0 = {
		htole16(0x0409), /* en-us */
		STR_INTERFACE,
	},
};

/******************** Endpoints handling *******************************/

static void display_event(struct usb_functionfs_event *event)
{
	static const char *const names[] = {
		[FUNCTIONFS_BIND] = "BIND",
		[FUNCTIONFS_UNBIND] = "UNBIND",
		[FUNCTIONFS_ENABLE] = "ENABLE",
		[FUNCTIONFS_DISABLE] = "DISABLE",
		[FUNCTIONFS_SETUP] = "SETUP",
		[FUNCTIONFS_SUSPEND] = "SUSPEND",
		[FUNCTIONFS_RESUME] = "RESUME",
	};
	switch (event->type) {
	case FUNCTIONFS_BIND:
	case FUNCTIONFS_UNBIND:
	case FUNCTIONFS_ENABLE:
	case FUNCTIONFS_DISABLE:
	case FUNCTIONFS_SETUP:
	case FUNCTIONFS_SUSPEND:
	case FUNCTIONFS_RESUME:
		printf("Event %s\n", names[event->type]);
	}
}

static void handle_ep0(int ep0, bool *ready)
{
	struct usb_functionfs_event event;
	int ret;

	struct pollfd pfds[1];
	pfds[0].fd = ep0;
	pfds[0].events = POLLIN;

	ret = poll(pfds, 1, 0);

	if (ret && (pfds[0].revents & POLLIN)) {
		ret = read(ep0, &event, sizeof(event));
		if (!ret) {
			perror("unable to read event from ep0");
			return;
		}
		display_event(&event);
		switch (event.type) {
		case FUNCTIONFS_SETUP:
			if (event.u.setup.bRequestType & USB_DIR_IN)
				write(ep0, NULL, 0);
			else
				read(ep0, NULL, 0);
			break;

		case FUNCTIONFS_ENABLE:
			*ready = true;
			break;

		case FUNCTIONFS_DISABLE:
			*ready = false;
			break;

		default:
			break;
		}
	}
}

int main(int argc, char *argv[])
{
	int i, ret;
	char *ep_path;

	int ep0;
	int ep[2];

	io_context_t ctx;

	int evfd;
	fd_set rfds;

	char *buf_in, *buf_out;
	struct iocb *iocb_in, *iocb_out;
	int req_in = 0, req_out = 0;
	bool ready;

	if (argc != 2) {
		printf("ffs directory not specified!\n");
		return 1;
	}

	ep_path = malloc(strlen(argv[1]) + 4 /* "/ep#" */ + 1 /* '\0' */);
	if (!ep_path) {
		perror("malloc");
		return 1;
	}

	/* open endpoint files */
	sprintf(ep_path, "%s/ep0", argv[1]);
	ep0 = open(ep_path, O_RDWR);
	if (ep0 < 0) {
		perror("unable to open ep0");
		return 1;
	}
	if (write(ep0, &descriptors, sizeof(descriptors)) < 0) {
		perror("unable do write descriptors");
		return 1;
	}
	if (write(ep0, &strings, sizeof(strings)) < 0) {
		perror("unable to write strings");
		return 1;
	}
	for (i = 0; i < 2; ++i) {
		sprintf(ep_path, "%s/ep%d", argv[1], i+1);
		ep[i] = open(ep_path, O_RDWR);
		if (ep[i] < 0) {
			printf("unable to open ep%d: %s\n", i+1,
			       strerror(errno));
			return 1;
		}
	}

	free(ep_path);

	memset(&ctx, 0, sizeof(ctx));
	/* setup aio context to handle up to 2 requests */
	if (io_setup(2, &ctx) < 0) {
		perror("unable to setup aio");
		return 1;
	}

	evfd = eventfd(0, 0);
	if (evfd < 0) {
		perror("unable to open eventfd");
		return 1;
	}

	/* alloc buffers and requests */
	buf_in = malloc(BUF_LEN);
	buf_out = malloc(BUF_LEN);
	iocb_in = malloc(sizeof(*iocb_in));
	iocb_out = malloc(sizeof(*iocb_out));

	while (1) {
		FD_ZERO(&rfds);
		FD_SET(ep0, &rfds);
		FD_SET(evfd, &rfds);

		ret = select(((ep0 > evfd) ? ep0 : evfd)+1,
			     &rfds, NULL, NULL, NULL);
		if (ret < 0) {
			if (errno == EINTR)
				continue;
			perror("select");
			break;
		}

		if (FD_ISSET(ep0, &rfds))
			handle_ep0(ep0, &ready);

		/* we are waiting for function ENABLE */
		if (!ready)
			continue;

		/* if something was submitted we wait for event */
		if (FD_ISSET(evfd, &rfds)) {
			uint64_t ev_cnt;
			ret = read(evfd, &ev_cnt, sizeof(ev_cnt));
			if (ret < 0) {
				perror("unable to read eventfd");
				break;
			}

			struct io_event e[2];
			/* we wait for one event */
			ret = io_getevents(ctx, 1, 2, e, NULL);
			/* if we got event */
			for (i = 0; i < ret; ++i) {
				if (e[i].obj->aio_fildes == ep[0]) {
					printf("ev=in; ret=%lu\n", e[i].res);
					req_in = 0;
				} else if (e[i].obj->aio_fildes == ep[1]) {
					printf("ev=out; ret=%lu\n", e[i].res);
					req_out = 0;
				}
			}
		}

		if (!req_in) { /* if IN transfer not requested*/
			/* prepare write request */
			io_prep_pwrite(iocb_in, ep[0], buf_in, BUF_LEN, 0);
			/* enable eventfd notification */
			iocb_in->u.c.flags |= IOCB_FLAG_RESFD;
			iocb_in->u.c.resfd = evfd;
			/* submit table of requests */
			ret = io_submit(ctx, 1, &iocb_in);
			if (ret >= 0) { /* if ret > 0 request is queued */
				req_in = 1;
				printf("submit: in\n");
			} else
				perror("unable to submit request");
		}
		if (!req_out) { /* if OUT transfer not requested */
			/* prepare read request */
			io_prep_pread(iocb_out, ep[1], buf_out, BUF_LEN, 0);
			/* enable eventfs notification */
			iocb_out->u.c.flags |= IOCB_FLAG_RESFD;
			iocb_out->u.c.resfd = evfd;
			/* submit table of requests */
			ret = io_submit(ctx, 1, &iocb_out);
			if (ret >= 0) { /* if ret > 0 request is queued */
				req_out = 1;
				printf("submit: out\n");
			} else
				perror("unable to submit request");
		}
	}

	/* free resources */

	io_destroy(ctx);

	free(buf_in);
	free(buf_out);
	free(iocb_in);
	free(iocb_out);

	for (i = 0; i < 2; ++i)
		close(ep[i]);
	close(ep0);

	return 0;
}
Commit	Line	Data
aa491320 RB	1	/*
	2	* This is free and unencumbered software released into the public domain.
	3	*
	4	* Anyone is free to copy, modify, publish, use, compile, sell, or
	5	* distribute this software, either in source code form or as a compiled
	6	* binary, for any purpose, commercial or non-commercial, and by any
	7	* means.
	8	*
	9	* In jurisdictions that recognize copyright laws, the author or authors
	10	* of this software dedicate any and all copyright interest in the
	11	* software to the public domain. We make this dedication for the benefit
	12	* of the public at large and to the detriment of our heirs and
	13	* successors. We intend this dedication to be an overt act of
	14	* relinquishment in perpetuity of all present and future rights to this
	15	* software under copyright law.
	16	*
	17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	18	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	19	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	20	* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	21	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	22	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	23	* OTHER DEALINGS IN THE SOFTWARE.
	24	*
	25	* For more information, please refer to <http://unlicense.org/>
	26	*/
	27
b34e08d5 RB	28	#define _BSD_SOURCE /* for endian.h */
	29
	30	#include <endian.h>
	31	#include <errno.h>
	32	#include <fcntl.h>
	33	#include <stdarg.h>
	34	#include <stdio.h>
	35	#include <stdlib.h>
	36	#include <string.h>
	37	#include <sys/ioctl.h>
	38	#include <sys/stat.h>
	39	#include <sys/types.h>
	40	#include <sys/poll.h>
	41	#include <unistd.h>
	42	#include <stdbool.h>
	43	#include <sys/eventfd.h>
	44
	45	#include "libaio.h"
	46	#define IOCB_FLAG_RESFD (1 << 0)
	47
	48	#include <linux/usb/functionfs.h>
	49
	50	#define BUF_LEN 8192
	51
	52	/****************** Descriptors and Strings *****************************/
	53
	54	static const struct {
0ebe9910 RB	55	struct usb_functionfs_descs_head_v2 header;
	56	__le32 fs_count;
	57	__le32 hs_count;
b34e08d5 RB	58	struct {
	59	struct usb_interface_descriptor intf;
	60	struct usb_endpoint_descriptor_no_audio bulk_sink;
	61	struct usb_endpoint_descriptor_no_audio bulk_source;
	62	} __attribute__ ((__packed__)) fs_descs, hs_descs;
	63	} __attribute__ ((__packed__)) descriptors = {
	64	.header = {
0ebe9910 RB	65	.magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),
	66	.flags = htole32(FUNCTIONFS_HAS_FS_DESC \|
	67	FUNCTIONFS_HAS_HS_DESC),
b34e08d5	68	.length = htole32(sizeof(descriptors)),
b34e08d5	69	},
0ebe9910	70	.fs_count = htole32(3),
b34e08d5 RB	71	.fs_descs = {
	72	.intf = {
	73	.bLength = sizeof(descriptors.fs_descs.intf),
	74	.bDescriptorType = USB_DT_INTERFACE,
	75	.bNumEndpoints = 2,
	76	.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
	77	.iInterface = 1,
	78	},
	79	.bulk_sink = {
	80	.bLength = sizeof(descriptors.fs_descs.bulk_sink),
	81	.bDescriptorType = USB_DT_ENDPOINT,
	82	.bEndpointAddress = 1 \| USB_DIR_IN,
	83	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	84	},
	85	.bulk_source = {
	86	.bLength = sizeof(descriptors.fs_descs.bulk_source),
	87	.bDescriptorType = USB_DT_ENDPOINT,
	88	.bEndpointAddress = 2 \| USB_DIR_OUT,
	89	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	90	},
	91	},
0ebe9910	92	.hs_count = htole32(3),
b34e08d5 RB	93	.hs_descs = {
	94	.intf = {
	95	.bLength = sizeof(descriptors.hs_descs.intf),
	96	.bDescriptorType = USB_DT_INTERFACE,
	97	.bNumEndpoints = 2,
	98	.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
	99	.iInterface = 1,
	100	},
	101	.bulk_sink = {
	102	.bLength = sizeof(descriptors.hs_descs.bulk_sink),
	103	.bDescriptorType = USB_DT_ENDPOINT,
	104	.bEndpointAddress = 1 \| USB_DIR_IN,
	105	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	106	},
	107	.bulk_source = {
	108	.bLength = sizeof(descriptors.hs_descs.bulk_source),
	109	.bDescriptorType = USB_DT_ENDPOINT,
	110	.bEndpointAddress = 2 \| USB_DIR_OUT,
	111	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	112	},
	113	},
	114	};
	115
	116	#define STR_INTERFACE "AIO Test"
	117
	118	static const struct {
	119	struct usb_functionfs_strings_head header;
	120	struct {
	121	__le16 code;
	122	const char str1[sizeof(STR_INTERFACE)];
	123	} __attribute__ ((__packed__)) lang0;
	124	} __attribute__ ((__packed__)) strings = {
	125	.header = {
	126	.magic = htole32(FUNCTIONFS_STRINGS_MAGIC),
	127	.length = htole32(sizeof(strings)),
	128	.str_count = htole32(1),
	129	.lang_count = htole32(1),
	130	},
	131	.lang0 = {
	132	htole16(0x0409), /* en-us */
	133	STR_INTERFACE,
	134	},
	135	};
	136
	137	/****************** Endpoints handling *****************************/
	138
	139	static void display_event(struct usb_functionfs_event *event)
	140	{
	141	static const char *const names[] = {
	142	[FUNCTIONFS_BIND] = "BIND",
	143	[FUNCTIONFS_UNBIND] = "UNBIND",
	144	[FUNCTIONFS_ENABLE] = "ENABLE",
	145	[FUNCTIONFS_DISABLE] = "DISABLE",
	146	[FUNCTIONFS_SETUP] = "SETUP",
	147	[FUNCTIONFS_SUSPEND] = "SUSPEND",
	148	[FUNCTIONFS_RESUME] = "RESUME",
	149	};
	150	switch (event->type) {
	151	case FUNCTIONFS_BIND:
	152	case FUNCTIONFS_UNBIND:
	153	case FUNCTIONFS_ENABLE:
	154	case FUNCTIONFS_DISABLE:
	155	case FUNCTIONFS_SETUP:
	156	case FUNCTIONFS_SUSPEND:
157	case FUNCTIONFS_RESUME:
158	printf("Event %s\n", names[event->type]);
159	}
160	}
161
162	static void handle_ep0(int ep0, bool *ready)
163	{
164	struct usb_functionfs_event event;
165	int ret;
166
167	struct pollfd pfds[1];
168	pfds[0].fd = ep0;
169	pfds[0].events = POLLIN;
170
171	ret = poll(pfds, 1, 0);
172
173	if (ret && (pfds[0].revents & POLLIN)) {
174	ret = read(ep0, &event, sizeof(event));
175	if (!ret) {
176	perror("unable to read event from ep0");
177	return;
178	}
179	display_event(&event);
180	switch (event.type) {
181	case FUNCTIONFS_SETUP:
182	if (event.u.setup.bRequestType & USB_DIR_IN)
183	write(ep0, NULL, 0);
184	else
185	read(ep0, NULL, 0);
186	break;
187
188	case FUNCTIONFS_ENABLE:
189	*ready = true;
190	break;
191
192	case FUNCTIONFS_DISABLE:
193	*ready = false;
194	break;
195
196	default:
197	break;
198	}
199	}
200	}
201
202	int main(int argc, char *argv[])
203	{
204	int i, ret;
205	char *ep_path;
206
207	int ep0;
208	int ep[2];
209
210	io_context_t ctx;
211
212	int evfd;
213	fd_set rfds;
214
215	char buf_in, buf_out;
216	struct iocb iocb_in, iocb_out;
217	int req_in = 0, req_out = 0;
218	bool ready;
219
220	if (argc != 2) {
221	printf("ffs directory not specified!\n");
222	return 1;
223	}
224
225	ep_path = malloc(strlen(argv[1]) + 4 /* "/ep#" / + 1 / '\0' */);
226	if (!ep_path) {
227	perror("malloc");
228	return 1;
229	}
230
231	/* open endpoint files */
232	sprintf(ep_path, "%s/ep0", argv[1]);
233	ep0 = open(ep_path, O_RDWR);
234	if (ep0 < 0) {
235	perror("unable to open ep0");
236	return 1;
237	}
238	if (write(ep0, &descriptors, sizeof(descriptors)) < 0) {
239	perror("unable do write descriptors");
240	return 1;
241	}
242	if (write(ep0, &strings, sizeof(strings)) < 0) {
243	perror("unable to write strings");
244	return 1;
245	}
246	for (i = 0; i < 2; ++i) {
247	sprintf(ep_path, "%s/ep%d", argv[1], i+1);
248	ep[i] = open(ep_path, O_RDWR);
249	if (ep[i] < 0) {
250	printf("unable to open ep%d: %s\n", i+1,
251	strerror(errno));
252	return 1;
253	}
254	}
255
256	free(ep_path);
257
258	memset(&ctx, 0, sizeof(ctx));
259	/* setup aio context to handle up to 2 requests */
260	if (io_setup(2, &ctx) < 0) {
261	perror("unable to setup aio");
262	return 1;
263	}
264
265	evfd = eventfd(0, 0);
266	if (evfd < 0) {
267	perror("unable to open eventfd");
268	return 1;
269	}
270
271	/* alloc buffers and requests */
272	buf_in = malloc(BUF_LEN);
273	buf_out = malloc(BUF_LEN);
274	iocb_in = malloc(sizeof(*iocb_in));
275	iocb_out = malloc(sizeof(*iocb_out));
276
277	while (1) {
278	FD_ZERO(&rfds);
279	FD_SET(ep0, &rfds);
280	FD_SET(evfd, &rfds);
281
282	ret = select(((ep0 > evfd) ? ep0 : evfd)+1,
283	&rfds, NULL, NULL, NULL);
284	if (ret < 0) {
285	if (errno == EINTR)
286	continue;
287	perror("select");
288	break;
289	}
290
291	if (FD_ISSET(ep0, &rfds))
292	handle_ep0(ep0, &ready);
293
294	/* we are waiting for function ENABLE */
295	if (!ready)
296	continue;
297
298	/* if something was submitted we wait for event */
299	if (FD_ISSET(evfd, &rfds)) {
300	uint64_t ev_cnt;
301	ret = read(evfd, &ev_cnt, sizeof(ev_cnt));
302	if (ret < 0) {
303	perror("unable to read eventfd");
304	break;
305	}
306
307	struct io_event e[2];
308	/* we wait for one event */
309	ret = io_getevents(ctx, 1, 2, e, NULL);
310	/* if we got event */
311	for (i = 0; i < ret; ++i) {
312	if (e[i].obj->aio_fildes == ep[0]) {
313	printf("ev=in; ret=%lu\n", e[i].res);
314	req_in = 0;
315	} else if (e[i].obj->aio_fildes == ep[1]) {
316	printf("ev=out; ret=%lu\n", e[i].res);
317	req_out = 0;
318	}
319	}
320	}
321
322	if (!req_in) { /* if IN transfer not requested*/
323	/* prepare write request */
324	io_prep_pwrite(iocb_in, ep[0], buf_in, BUF_LEN, 0);
325	/* enable eventfd notification */
326	iocb_in->u.c.flags \|= IOCB_FLAG_RESFD;
327	iocb_in->u.c.resfd = evfd;
328	/* submit table of requests */
329	ret = io_submit(ctx, 1, &iocb_in);
330	if (ret >= 0) { /* if ret > 0 request is queued */
331	req_in = 1;
332	printf("submit: in\n");
333	} else
334	perror("unable to submit request");
335	}
336	if (!req_out) { /* if OUT transfer not requested */
337	/* prepare read request */
338	io_prep_pread(iocb_out, ep[1], buf_out, BUF_LEN, 0);
339	/* enable eventfs notification */
340	iocb_out->u.c.flags \|= IOCB_FLAG_RESFD;
341	iocb_out->u.c.resfd = evfd;
342	/* submit table of requests */
343	ret = io_submit(ctx, 1, &iocb_out);
344	if (ret >= 0) { /* if ret > 0 request is queued */
345	req_out = 1;
346	printf("submit: out\n");
347	} else
348	perror("unable to submit request");
349	}
350	}
351
352	/* free resources */
353
354	io_destroy(ctx);
355
356	free(buf_in);
357	free(buf_out);
358	free(iocb_in);
359	free(iocb_out);
360
361	for (i = 0; i < 2; ++i)
362	close(ep[i]);
363	close(ep0);
364
365	return 0;
366	}