1/*-
2 * Copyright (c) 2004 Robert N. M. Watson
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD$
27 */
28
29/*
30 * Regression test to do some very basic AIO exercising on several types of
31 * file descriptors.  Currently, the tests consist of initializing a fixed
32 * size buffer with pseudo-random data, writing it to one fd using AIO, then
33 * reading it from a second descriptor using AIO.  For some targets, the same
34 * fd is used for write and read (i.e., file, md device), but for others the
35 * operation is performed on a peer (pty, socket, fifo, etc).  A timeout is
36 * initiated to detect undo blocking.  This test does not attempt to exercise
37 * error cases or more subtle asynchronous behavior, just make sure that the
38 * basic operations work on some basic object types.
39 */
40
41#include <sys/types.h>
42#include <sys/socket.h>
43#include <sys/stat.h>
44#include <sys/mdioctl.h>
45
46#include <aio.h>
47#include <err.h>
48#include <errno.h>
49#include <fcntl.h>
50#include <libutil.h>
51#include <limits.h>
52#include <stdint.h>
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <termios.h>
57#include <unistd.h>
58
59#define	PATH_TEMPLATE	"/tmp/aio.XXXXXXXXXX"
60
61/*
62 * GLOBAL_MAX sets the largest usable buffer size to be read and written, as
63 * it sizes ac_buffer in the aio_context structure.  It is also the default
64 * size for file I/O.  For other types, we use smaller blocks or we risk
65 * blocking (and we run in a single process/thread so that would be bad).
66 */
67#define	GLOBAL_MAX	16384
68
69#define	BUFFER_MAX	GLOBAL_MAX
70struct aio_context {
71	const char	*ac_test;
72	int		 ac_read_fd, ac_write_fd;
73	long		 ac_seed;
74	char		 ac_buffer[GLOBAL_MAX];
75	int		 ac_buflen;
76	int		 ac_seconds;
77	void		 (*ac_cleanup)(void *arg);
78	void		*ac_cleanup_arg;
79};
80
81static int	aio_timedout;
82static int	aio_notpresent;
83
84/*
85 * Attempt to provide a cleaner failure mode in the event AIO support is not
86 * present by catching and reporting SIGSYS.
87 */
88static void
89aio_sigsys(int sig)
90{
91
92	aio_notpresent = 1;
93}
94
95static void
96aio_sigsys_setup(void)
97{
98
99	if (signal(SIGSYS, aio_sigsys) == SIG_ERR)
100		errx(-1, "FAIL: signal(SIGSYS): %s", strerror(errno));
101}
102
103/*
104 * Each test run specifies a timeout in seconds.  Use the somewhat obsoleted
105 * signal(3) and alarm(3) APIs to set this up.
106 */
107static void
108aio_timeout_signal(int sig)
109{
110
111	aio_timedout = 1;
112}
113
114static void
115aio_timeout_start(const char *string1, const char *string2, int seconds)
116{
117
118	aio_timedout = 0;
119	if (signal(SIGALRM, aio_timeout_signal) == SIG_ERR)
120		errx(-1, "FAIL: %s: %s: aio_timeout_set: signal(SIGALRM): %s",
121		    string1, string2, strerror(errno));
122	alarm(seconds);
123}
124
125static void
126aio_timeout_stop(const char *string1, const char *string2)
127{
128
129	if (signal(SIGALRM, NULL) == SIG_ERR)
130		errx(-1, "FAIL: %s: %s: aio_timeout_stop: signal(NULL): %s",
131		    string1, string2, strerror(errno));
132	alarm(0);
133}
134
135/*
136 * Fill a buffer given a seed that can be fed into srandom() to initialize
137 * the PRNG in a repeatable manner.
138 */
139static void
140aio_fill_buffer(char *buffer, int len, long seed)
141{
142	char ch;
143	int i;
144
145	srandom(seed);
146	for (i = 0; i < len; i++) {
147		ch = random() & 0xff;
148		buffer[i] = ch;
149	}
150}
151
152/*
153 * Test that a buffer matches a given seed.  See aio_fill_buffer().  Return
154 * (1) on a match, (0) on a mismatch.
155 */
156static int
157aio_test_buffer(char *buffer, int len, long seed)
158{
159	char ch;
160	int i;
161
162	srandom(seed);
163	for (i = 0; i < len; i++) {
164		ch = random() & 0xff;
165		if (buffer[i] != ch)
166			return (0);
167	}
168	return (1);
169}
170
171/*
172 * Initialize a testing context given the file descriptors provided by the
173 * test setup.
174 */
175static void
176aio_context_init(struct aio_context *ac, const char *test, int read_fd,
177    int write_fd, int buflen, int seconds, void (*cleanup)(void *),
178    void *cleanup_arg)
179{
180
181	if (buflen > BUFFER_MAX)
182		errx(-1, "FAIL: %s: aio_context_init: buffer too large",
183		    test);
184	bzero(ac, sizeof(*ac));
185	ac->ac_test = test;
186	ac->ac_read_fd = read_fd;
187	ac->ac_write_fd = write_fd;
188	ac->ac_buflen = buflen;
189	srandomdev();
190	ac->ac_seed = random();
191	aio_fill_buffer(ac->ac_buffer, buflen, ac->ac_seed);
192	if (aio_test_buffer(ac->ac_buffer, buflen, ac->ac_seed) == 0)
193		errx(-1, "%s: aio_context_init: aio_test_buffer: internal "
194		    "error", test);
195	ac->ac_seconds = seconds;
196	ac->ac_cleanup = cleanup;
197	ac->ac_cleanup_arg = cleanup_arg;
198}
199
200/*
201 * Each tester can register a callback to clean up in the event the test
202 * fails.  Preserve the value of errno so that subsequent calls to errx()
203 * work properly.
204 */
205static void
206aio_cleanup(struct aio_context *ac)
207{
208	int error;
209
210	if (ac->ac_cleanup == NULL)
211		return;
212	error = errno;
213	(ac->ac_cleanup)(ac->ac_cleanup_arg);
214	errno = error;
215}
216
217/*
218 * Perform a simple write test of our initialized data buffer to the provided
219 * file descriptor.
220 */
221static void
222aio_write_test(struct aio_context *ac)
223{
224	struct aiocb aio, *aiop;
225	ssize_t len;
226	int error;
227
228	bzero(&aio, sizeof(aio));
229	aio.aio_buf = ac->ac_buffer;
230	aio.aio_nbytes = ac->ac_buflen;
231	aio.aio_fildes = ac->ac_write_fd;
232	aio.aio_offset = 0;
233
234	aio_timeout_start(ac->ac_test, "aio_write_test", ac->ac_seconds);
235
236	if (aio_write(&aio) < 0) {
237		if (errno == EINTR) {
238			if (aio_notpresent)
239				errno = EOPNOTSUPP;
240			if (aio_timedout) {
241				aio_cleanup(ac);
242				errx(-1, "FAIL: %s: aio_write_test: "
243				    "aio_write: timed out", ac->ac_test);
244			}
245		}
246		aio_cleanup(ac);
247		errx(-1, "FAIL: %s: aio_write_test: aio_write: %s",
248		    ac->ac_test, strerror(errno));
249	}
250
251	len = aio_waitcomplete(&aiop, NULL);
252	if (len < 0) {
253		if (errno == EINTR) {
254			if (aio_notpresent)
255				errno = EOPNOTSUPP;
256			if (aio_timedout) {
257				aio_cleanup(ac);
258				errx(-1, "FAIL: %s: aio_write_test: "
259				    "aio_waitcomplete: timed out",
260				    ac->ac_test);
261			}
262		}
263		aio_cleanup(ac);
264		errx(-1, "FAIL: %s: aio_write_test: aio_waitcomplete: %s",
265		    ac->ac_test, strerror(errno));
266	}
267
268	aio_timeout_stop(ac->ac_test, "aio_write_test");
269
270	if (len != ac->ac_buflen) {
271		aio_cleanup(ac);
272		errx(-1, "FAIL: %s: aio_write_test: aio_waitcomplete: short "
273		    "write (%jd)", ac->ac_test, (intmax_t)len);
274	}
275}
276
277/*
278 * Perform a simple read test of our initialized data buffer from the
279 * provided file descriptor.
280 */
281static void
282aio_read_test(struct aio_context *ac)
283{
284	struct aiocb aio, *aiop;
285	ssize_t len;
286
287	bzero(ac->ac_buffer, ac->ac_buflen);
288	bzero(&aio, sizeof(aio));
289	aio.aio_buf = ac->ac_buffer;
290	aio.aio_nbytes = ac->ac_buflen;
291	aio.aio_fildes = ac->ac_read_fd;
292	aio.aio_offset = 0;
293
294	aio_timeout_start(ac->ac_test, "aio_read_test", ac->ac_seconds);
295
296	if (aio_read(&aio) < 0) {
297		if (errno == EINTR) {
298			if (aio_notpresent)
299				errno = EOPNOTSUPP;
300			if (aio_timedout) {
301				aio_cleanup(ac);
302				errx(-1, "FAIL: %s: aio_read_test: "
303				    "aio_read: timed out", ac->ac_test);
304			}
305		}
306		aio_cleanup(ac);
307		errx(-1, "FAIL: %s: aio_read_test: aio_read %s", ac->ac_test,
308		    strerror(errno));
309	}
310
311	len = aio_waitcomplete(&aiop, NULL);
312	if (len < 0) {
313		if (errno == EINTR) {
314			if (aio_notpresent)
315				errno = EOPNOTSUPP;
316			if (aio_timedout) {
317				aio_cleanup(ac);
318				errx(-1, "FAIL: %s: aio_read_test: "
319				    "aio_waitcomplete: timed out",
320				    ac->ac_test);
321			}
322		}
323		aio_cleanup(ac);
324		errx(-1, "FAIL: %s: aio_read_test: aio_waitcomplete: %s",
325		    ac->ac_test, strerror(errno));
326	}
327
328	aio_timeout_stop(ac->ac_test, "aio_read_test");
329
330	if (len != ac->ac_buflen) {
331		aio_cleanup(ac);
332		errx(-1, "FAIL: %s: aio_read_test: aio_waitcomplete: short "
333		    "read (%jd)", ac->ac_test, (intmax_t)len);
334	}
335
336	if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0) {
337		aio_cleanup(ac);
338		errx(-1, "FAIL: %s: aio_read_test: buffer mismatch",
339		    ac->ac_test);
340	}
341}
342
343/*
344 * Series of type-specific tests for AIO.  For now, we just make sure we can
345 * issue a write and then a read to each type.  We assume that once a write
346 * is issued, a read can follow.
347 */
348
349/*
350 * Test with a classic file.  Assumes we can create a moderate size temporary
351 * file.
352 */
353struct aio_file_arg {
354	int	 afa_fd;
355	char	*afa_pathname;
356};
357
358static void
359aio_file_cleanup(void *arg)
360{
361	struct aio_file_arg *afa;
362
363	afa = arg;
364	close(afa->afa_fd);
365	unlink(afa->afa_pathname);
366}
367
368#define	FILE_LEN	GLOBAL_MAX
369#define	FILE_TIMEOUT	30
370static void
371aio_file_test(void)
372{
373	char pathname[PATH_MAX];
374	struct aio_file_arg arg;
375	struct aio_context ac;
376	int fd;
377
378	strcpy(pathname, PATH_TEMPLATE);
379	fd = mkstemp(pathname);
380	if (fd == -1)
381		errx(-1, "FAIL: aio_file_test: mkstemp: %s",
382		    strerror(errno));
383
384	arg.afa_fd = fd;
385	arg.afa_pathname = pathname;
386
387	aio_context_init(&ac, "aio_file_test", fd, fd, FILE_LEN,
388	    FILE_TIMEOUT, aio_file_cleanup, &arg);
389	aio_write_test(&ac);
390	aio_read_test(&ac);
391
392	aio_file_cleanup(&arg);
393
394	fprintf(stderr, "PASS: aio_file_test\n");
395}
396
397struct aio_fifo_arg {
398	int	 afa_read_fd;
399	int	 afa_write_fd;
400	char	*afa_pathname;
401};
402
403static void
404aio_fifo_cleanup(void *arg)
405{
406	struct aio_fifo_arg *afa;
407
408	afa = arg;
409	if (afa->afa_read_fd != -1)
410		close(afa->afa_read_fd);
411	if (afa->afa_write_fd != -1)
412		close(afa->afa_write_fd);
413	unlink(afa->afa_pathname);
414}
415
416#define	FIFO_LEN	256
417#define	FIFO_TIMEOUT	30
418static void
419aio_fifo_test(void)
420{
421	int error, read_fd = -1, write_fd = -1;
422	struct aio_fifo_arg arg;
423	char pathname[PATH_MAX];
424	struct aio_context ac;
425
426	/*
427	 * In theory, mktemp() can return a name that is then collided with.
428	 * Because this is a regression test, we treat that as a test failure
429	 * rather than retrying.
430	 */
431	strcpy(pathname, PATH_TEMPLATE);
432	mktemp(pathname);
433	if (mkfifo(pathname, 0600) == -1)
434		errx(-1, "FAIL: aio_fifo_test: mkfifo: %s", strerror(errno));
435	arg.afa_pathname = pathname;
436	arg.afa_read_fd = -1;
437	arg.afa_write_fd = -1;
438
439	read_fd = open(pathname, O_RDONLY | O_NONBLOCK);
440	if (read_fd == -1) {
441		error = errno;
442		aio_fifo_cleanup(&arg);
443		errno = error;
444		errx(-1, "FAIL: aio_fifo_test: read_fd open: %s",
445		    strerror(errno));
446	}
447	arg.afa_read_fd = read_fd;
448
449	write_fd = open(pathname, O_WRONLY);
450	if (write_fd == -1) {
451		error = errno;
452		aio_fifo_cleanup(&arg);
453		errno = error;
454		errx(-1, "FAIL: aio_fifo_test: write_fd open: %s",
455		    strerror(errno));
456	}
457	arg.afa_write_fd = write_fd;
458
459	aio_context_init(&ac, "aio_fifo_test", read_fd, write_fd, FIFO_LEN,
460	    FIFO_TIMEOUT, aio_fifo_cleanup, &arg);
461	aio_write_test(&ac);
462	aio_read_test(&ac);
463
464	aio_fifo_cleanup(&arg);
465
466	fprintf(stderr, "PASS: aio_fifo_test\n");
467}
468
469struct aio_unix_socketpair_arg {
470	int	asa_sockets[2];
471};
472
473static void
474aio_unix_socketpair_cleanup(void *arg)
475{
476	struct aio_unix_socketpair_arg *asa;
477
478	asa = arg;
479	close(asa->asa_sockets[0]);
480	close(asa->asa_sockets[1]);
481}
482
483#define	UNIX_SOCKETPAIR_LEN	256
484#define	UNIX_SOCKETPAIR_TIMEOUT	30
485static void
486aio_unix_socketpair_test(void)
487{
488	struct aio_unix_socketpair_arg arg;
489	struct aio_context ac;
490	int sockets[2];
491
492	if (socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) < 0)
493		errx(-1, "FAIL: aio_socketpair_test: socketpair: %s",
494		    strerror(errno));
495
496	arg.asa_sockets[0] = sockets[0];
497	arg.asa_sockets[1] = sockets[1];
498	aio_context_init(&ac, "aio_unix_socketpair_test", sockets[0],
499	    sockets[1], UNIX_SOCKETPAIR_LEN, UNIX_SOCKETPAIR_TIMEOUT,
500	    aio_unix_socketpair_cleanup, &arg);
501	aio_write_test(&ac);
502	aio_read_test(&ac);
503
504	aio_unix_socketpair_cleanup(&arg);
505
506	fprintf(stderr, "PASS: aio_unix_socketpair_test\n");
507}
508
509struct aio_pty_arg {
510	int	apa_read_fd;
511	int	apa_write_fd;
512};
513
514static void
515aio_pty_cleanup(void *arg)
516{
517	struct aio_pty_arg *apa;
518
519	apa = arg;
520	close(apa->apa_read_fd);
521	close(apa->apa_write_fd);
522};
523
524#define	PTY_LEN		256
525#define	PTY_TIMEOUT	30
526static void
527aio_pty_test(void)
528{
529	struct aio_pty_arg arg;
530	struct aio_context ac;
531	int read_fd, write_fd;
532	struct termios ts;
533	int error;
534
535	if (openpty(&read_fd, &write_fd, NULL, NULL, NULL) < 0)
536		errx(-1, "FAIL: aio_pty_test: openpty: %s", strerror(errno));
537
538	arg.apa_read_fd = read_fd;
539	arg.apa_write_fd = write_fd;
540
541	if (tcgetattr(write_fd, &ts) < 0) {
542		error = errno;
543		aio_pty_cleanup(&arg);
544		errno = error;
545		errx(-1, "FAIL: aio_pty_test: tcgetattr: %s",
546		    strerror(errno));
547	}
548	cfmakeraw(&ts);
549	if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
550		error = errno;
551		aio_pty_cleanup(&arg);
552		errno = error;
553		errx(-1, "FAIL: aio_pty_test: tcsetattr: %s",
554		    strerror(errno));
555	}
556
557	aio_context_init(&ac, "aio_pty_test", read_fd, write_fd, PTY_LEN,
558	    PTY_TIMEOUT, aio_pty_cleanup, &arg);
559	aio_write_test(&ac);
560	aio_read_test(&ac);
561
562	aio_pty_cleanup(&arg);
563
564	fprintf(stderr, "PASS: aio_pty_test\n");
565}
566
567static void
568aio_pipe_cleanup(void *arg)
569{
570	int *pipes = arg;
571
572	close(pipes[0]);
573	close(pipes[1]);
574}
575
576#define	PIPE_LEN	256
577#define	PIPE_TIMEOUT	30
578static void
579aio_pipe_test(void)
580{
581	struct aio_context ac;
582	int pipes[2];
583
584	if (pipe(pipes) < 0)
585		errx(-1, "FAIL: aio_pipe_test: pipe: %s", strerror(errno));
586
587	aio_context_init(&ac, "aio_file_test", pipes[0], pipes[1], PIPE_LEN,
588	    PIPE_TIMEOUT, aio_pipe_cleanup, pipes);
589	aio_write_test(&ac);
590	aio_read_test(&ac);
591
592	aio_pipe_cleanup(pipes);
593
594	fprintf(stderr, "PASS: aio_pipe_test\n");
595}
596
597struct aio_md_arg {
598	int	ama_mdctl_fd;
599	int	ama_unit;
600	int	ama_fd;
601};
602
603static void
604aio_md_cleanup(void *arg)
605{
606	struct aio_md_arg *ama;
607	struct md_ioctl mdio;
608	int error;
609
610	ama = arg;
611
612	if (ama->ama_fd != -1)
613		close(ama->ama_fd);
614
615	if (ama->ama_unit != -1) {
616		bzero(&mdio, sizeof(mdio));
617		mdio.md_version = MDIOVERSION;
618		mdio.md_unit = ama->ama_unit;
619		if (ioctl(ama->ama_mdctl_fd, MDIOCDETACH, &mdio) < 0) {
620			error = errno;
621			close(ama->ama_mdctl_fd);
622			errno = error;
623			warnx("FAIL: aio_md_test: MDIOCDETACH: %s",
624			    strerror(errno));
625		}
626	}
627
628	close(ama->ama_mdctl_fd);
629}
630
631#define	MD_LEN		GLOBAL_MAX
632#define	MD_TIMEOUT	30
633static void
634aio_md_test(void)
635{
636	int error, fd, i, mdctl_fd, unit;
637	char pathname[PATH_MAX];
638	struct aio_md_arg arg;
639	struct aio_context ac;
640	struct md_ioctl mdio;
641
642	mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
643	if (mdctl_fd < 0)
644		errx(-1, "FAIL: aio_md_test: open(/dev/%s): %s", MDCTL_NAME,
645		    strerror(errno));
646
647	bzero(&mdio, sizeof(mdio));
648	mdio.md_version = MDIOVERSION;
649	mdio.md_type = MD_MALLOC;
650	mdio.md_options = MD_AUTOUNIT | MD_COMPRESS;
651	mdio.md_mediasize = GLOBAL_MAX;
652	mdio.md_sectorsize = 512;
653
654	arg.ama_mdctl_fd = mdctl_fd;
655	arg.ama_unit = -1;
656	arg.ama_fd = -1;
657	if (ioctl(mdctl_fd, MDIOCATTACH, &mdio) < 0) {
658		error = errno;
659		aio_md_cleanup(&arg);
660		errno = error;
661		errx(-1, "FAIL: aio_md_test: MDIOCATTACH: %s",
662		    strerror(errno));
663	}
664
665	arg.ama_unit = unit = mdio.md_unit;
666	snprintf(pathname, PATH_MAX, "/dev/md%d", unit);
667	fd = open(pathname, O_RDWR);
668	if (fd < 0) {
669		error = errno;
670		aio_md_cleanup(&arg);
671		errno = error;
672		errx(-1, "FAIL: aio_md_test: open(%s): %s", pathname,
673		    strerror(errno));
674	}
675	arg.ama_fd = fd;
676
677	aio_context_init(&ac, "aio_md_test", fd, fd, MD_LEN, MD_TIMEOUT,
678	    aio_md_cleanup, &arg);
679	aio_write_test(&ac);
680	aio_read_test(&ac);
681
682	aio_md_cleanup(&arg);
683
684	fprintf(stderr, "PASS: aio_md_test\n");
685}
686
687int
688main(int argc, char *argv[])
689{
690
691	aio_sigsys_setup();
692	aio_file_test();
693	aio_fifo_test();
694	aio_unix_socketpair_test();
695	aio_pty_test();
696	aio_pipe_test();
697	if (geteuid() == 0)
698		aio_md_test();
699	else
700		fprintf(stderr, "WARNING: aio_md_test: skipped as euid "
701		    "!= 0\n");
702}
703