2 * Copyright (c) 2004 Robert N. M. Watson
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
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.
41 #include <sys/types.h>
42 #include <sys/socket.h>
44 #include <sys/mdioctl.h>
58 #define PATH_TEMPLATE "/tmp/aio.XXXXXXXXXX"
61 * GLOBAL_MAX sets the largest usable buffer size to be read and written, as
62 * it sizes ac_buffer in the aio_context structure. It is also the default
63 * size for file I/O. For other types, we use smaller blocks or we risk
64 * blocking (and we run in a single process/thread so that would be bad).
66 #define GLOBAL_MAX 16384
68 #define BUFFER_MAX GLOBAL_MAX
71 int ac_read_fd, ac_write_fd;
73 char ac_buffer[GLOBAL_MAX];
76 void (*ac_cleanup)(void *arg);
80 static int aio_timedout;
81 static int aio_notpresent;
84 * Attempt to provide a cleaner failure mode in the event AIO support is not
85 * present by catching and reporting SIGSYS.
95 aio_sigsys_setup(void)
98 if (signal(SIGSYS, aio_sigsys) == SIG_ERR)
99 errx(-1, "FAIL: signal(SIGSYS): %s", strerror(errno));
103 * Each test run specifies a timeout in seconds. Use the somewhat obsoleted
104 * signal(3) and alarm(3) APIs to set this up.
107 aio_timeout_signal(int sig)
114 aio_timeout_start(const char *string1, const char *string2, int seconds)
118 if (signal(SIGALRM, aio_timeout_signal) == SIG_ERR)
119 errx(-1, "FAIL: %s: %s: aio_timeout_set: signal(SIGALRM): %s",
120 string1, string2, strerror(errno));
125 aio_timeout_stop(const char *string1, const char *string2)
128 if (signal(SIGALRM, NULL) == SIG_ERR)
129 errx(-1, "FAIL: %s: %s: aio_timeout_stop: signal(NULL): %s",
130 string1, string2, strerror(errno));
135 * Fill a buffer given a seed that can be fed into srandom() to initialize
136 * the PRNG in a repeatable manner.
139 aio_fill_buffer(char *buffer, int len, long seed)
145 for (i = 0; i < len; i++) {
146 ch = random() & 0xff;
152 * Test that a buffer matches a given seed. See aio_fill_buffer(). Return
153 * (1) on a match, (0) on a mismatch.
156 aio_test_buffer(char *buffer, int len, long seed)
162 for (i = 0; i < len; i++) {
163 ch = random() & 0xff;
171 * Initialize a testing context given the file descriptors provided by the
175 aio_context_init(struct aio_context *ac, const char *test, int read_fd,
176 int write_fd, int buflen, int seconds, void (*cleanup)(void *),
180 if (buflen > BUFFER_MAX)
181 errx(-1, "FAIL: %s: aio_context_init: buffer too large",
183 bzero(ac, sizeof(*ac));
185 ac->ac_read_fd = read_fd;
186 ac->ac_write_fd = write_fd;
187 ac->ac_buflen = buflen;
189 ac->ac_seed = random();
190 aio_fill_buffer(ac->ac_buffer, buflen, ac->ac_seed);
191 if (aio_test_buffer(ac->ac_buffer, buflen, ac->ac_seed) == 0)
192 errx(-1, "%s: aio_context_init: aio_test_buffer: internal "
194 ac->ac_seconds = seconds;
195 ac->ac_cleanup = cleanup;
196 ac->ac_cleanup_arg = cleanup_arg;
200 * Each tester can register a callback to clean up in the event the test
201 * fails. Preserve the value of errno so that subsequent calls to errx()
205 aio_cleanup(struct aio_context *ac)
209 if (ac->ac_cleanup == NULL)
212 (ac->ac_cleanup)(ac->ac_cleanup_arg);
217 * Perform a simple write test of our initialized data buffer to the provided
221 aio_write_test(struct aio_context *ac)
223 struct aiocb aio, *aiop;
227 bzero(&aio, sizeof(aio));
228 aio.aio_buf = ac->ac_buffer;
229 aio.aio_nbytes = ac->ac_buflen;
230 aio.aio_fildes = ac->ac_write_fd;
233 aio_timeout_start(ac->ac_test, "aio_write_test", ac->ac_seconds);
235 if (aio_write(&aio) < 0) {
236 if (errno == EINTR) {
241 errx(-1, "FAIL: %s: aio_write_test: "
242 "aio_write: timed out", ac->ac_test);
246 errx(-1, "FAIL: %s: aio_write_test: aio_write: %s",
247 ac->ac_test, strerror(errno));
250 len = aio_waitcomplete(&aiop, NULL);
252 if (errno == EINTR) {
257 errx(-1, "FAIL: %s: aio_write_test: "
258 "aio_waitcomplete: timed out",
263 errx(-1, "FAIL: %s: aio_write_test: aio_waitcomplete: %s",
264 ac->ac_test, strerror(errno));
267 aio_timeout_stop(ac->ac_test, "aio_write_test");
269 if (len != ac->ac_buflen) {
271 errx(-1, "FAIL: %s: aio_write_test: aio_waitcomplete: short "
272 "write (%d)", ac->ac_test, len);
277 * Perform a simple read test of our initialized data buffer from the
278 * provided file descriptor.
281 aio_read_test(struct aio_context *ac)
283 struct aiocb aio, *aiop;
286 bzero(ac->ac_buffer, ac->ac_buflen);
287 bzero(&aio, sizeof(aio));
288 aio.aio_buf = ac->ac_buffer;
289 aio.aio_nbytes = ac->ac_buflen;
290 aio.aio_fildes = ac->ac_read_fd;
293 aio_timeout_start(ac->ac_test, "aio_read_test", ac->ac_seconds);
295 if (aio_read(&aio) < 0) {
296 if (errno == EINTR) {
301 errx(-1, "FAIL: %s: aio_read_test: "
302 "aio_read: timed out", ac->ac_test);
306 errx(-1, "FAIL: %s: aio_read_test: aio_read %s", ac->ac_test,
310 len = aio_waitcomplete(&aiop, NULL);
312 if (errno == EINTR) {
317 errx(-1, "FAIL: %s: aio_read_test: "
318 "aio_waitcomplete: timed out",
323 errx(-1, "FAIL: %s: aio_read_test: aio_waitcomplete: %s",
324 ac->ac_test, strerror(errno));
327 aio_timeout_stop(ac->ac_test, "aio_read_test");
329 if (len != ac->ac_buflen) {
331 errx(-1, "FAIL: %s: aio_read_test: aio_waitcomplete: short "
332 "read (%d)", ac->ac_test, len);
335 if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0) {
337 errx(-1, "FAIL: %s: aio_read_test: buffer mismatch",
343 * Series of type-specific tests for AIO. For now, we just make sure we can
344 * issue a write and then a read to each type. We assume that once a write
345 * is issued, a read can follow.
349 * Test with a classic file. Assumes we can create a moderate size temporary
352 struct aio_file_arg {
358 aio_file_cleanup(void *arg)
360 struct aio_file_arg *afa;
364 unlink(afa->afa_pathname);
367 #define FILE_LEN GLOBAL_MAX
368 #define FILE_TIMEOUT 30
372 char pathname[PATH_MAX];
373 struct aio_file_arg arg;
374 struct aio_context ac;
377 strcpy(pathname, PATH_TEMPLATE);
378 fd = mkstemp(pathname);
380 errx(-1, "FAIL: aio_file_test: mkstemp: %s",
384 arg.afa_pathname = pathname;
386 aio_context_init(&ac, "aio_file_test", fd, fd, FILE_LEN,
387 FILE_TIMEOUT, aio_file_cleanup, &arg);
391 aio_file_cleanup(&arg);
393 fprintf(stderr, "PASS: aio_file_test\n");
396 struct aio_fifo_arg {
403 aio_fifo_cleanup(void *arg)
405 struct aio_fifo_arg *afa;
408 if (afa->afa_read_fd != -1)
409 close(afa->afa_read_fd);
410 if (afa->afa_write_fd != -1)
411 close(afa->afa_write_fd);
412 unlink(afa->afa_pathname);
416 #define FIFO_TIMEOUT 30
420 int error, read_fd = -1, write_fd = -1;
421 struct aio_fifo_arg arg;
422 char pathname[PATH_MAX];
423 struct aio_context ac;
426 * In theory, mktemp() can return a name that is then collided with.
427 * Because this is a regression test, we treat that as a test failure
428 * rather than retrying.
430 strcpy(pathname, PATH_TEMPLATE);
432 if (mkfifo(pathname, 0600) == -1)
433 errx(-1, "FAIL: aio_fifo_test: mkfifo: %s", strerror(errno));
434 arg.afa_pathname = pathname;
435 arg.afa_read_fd = -1;
436 arg.afa_write_fd = -1;
438 read_fd = open(pathname, O_RDONLY | O_NONBLOCK);
441 aio_fifo_cleanup(&arg);
443 errx(-1, "FAIL: aio_fifo_test: read_fd open: %s",
446 arg.afa_read_fd = read_fd;
448 write_fd = open(pathname, O_WRONLY);
449 if (write_fd == -1) {
451 aio_fifo_cleanup(&arg);
453 errx(-1, "FAIL: aio_fifo_test: write_fd open: %s",
456 arg.afa_write_fd = write_fd;
458 aio_context_init(&ac, "aio_fifo_test", read_fd, write_fd, FIFO_LEN,
459 FIFO_TIMEOUT, aio_fifo_cleanup, &arg);
463 aio_fifo_cleanup(&arg);
465 fprintf(stderr, "PASS: aio_fifo_test\n");
468 struct aio_unix_socketpair_arg {
473 aio_unix_socketpair_cleanup(void *arg)
475 struct aio_unix_socketpair_arg *asa;
478 close(asa->asa_sockets[0]);
479 close(asa->asa_sockets[1]);
482 #define UNIX_SOCKETPAIR_LEN 256
483 #define UNIX_SOCKETPAIR_TIMEOUT 30
485 aio_unix_socketpair_test(void)
487 struct aio_unix_socketpair_arg arg;
488 struct aio_context ac;
491 if (socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) < 0)
492 errx(-1, "FAIL: aio_socketpair_test: socketpair: %s",
495 arg.asa_sockets[0] = sockets[0];
496 arg.asa_sockets[1] = sockets[1];
497 aio_context_init(&ac, "aio_unix_socketpair_test", sockets[0],
498 sockets[1], UNIX_SOCKETPAIR_LEN, UNIX_SOCKETPAIR_TIMEOUT,
499 aio_unix_socketpair_cleanup, &arg);
503 aio_unix_socketpair_cleanup(&arg);
505 fprintf(stderr, "PASS: aio_unix_socketpair_test\n");
514 aio_pty_cleanup(void *arg)
516 struct aio_pty_arg *apa;
518 close(apa->apa_read_fd);
519 close(apa->apa_write_fd);
523 #define PTY_TIMEOUT 30
527 struct aio_pty_arg arg;
528 struct aio_context ac;
529 int read_fd, write_fd;
533 if (openpty(&read_fd, &write_fd, NULL, NULL, NULL) < 0)
534 errx(-1, "FAIL: aio_pty_test: openpty: %s", strerror(errno));
536 arg.apa_read_fd = read_fd;
537 arg.apa_write_fd = write_fd;
539 if (tcgetattr(write_fd, &ts) < 0) {
541 aio_pty_cleanup(&arg);
543 errx(-1, "FAIL: aio_pty_test: tcgetattr: %s",
547 if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
549 aio_pty_cleanup(&arg);
551 errx(-1, "FAIL: aio_pty_test: tcsetattr: %s",
555 aio_context_init(&ac, "aio_pty_test", read_fd, write_fd, PTY_LEN,
556 PTY_TIMEOUT, aio_pty_cleanup, &arg);
560 aio_pty_cleanup(&arg);
562 fprintf(stderr, "PASS: aio_pty_test\n");
566 aio_pipe_cleanup(void *arg)
575 #define PIPE_TIMEOUT 30
579 struct aio_context ac;
583 errx(-1, "FAIL: aio_pipe_test: pipe: %s", strerror(errno));
585 aio_context_init(&ac, "aio_file_test", pipes[0], pipes[1], PIPE_LEN,
586 PIPE_TIMEOUT, aio_pipe_cleanup, pipes);
590 aio_pipe_cleanup(pipes);
592 fprintf(stderr, "PASS: aio_pipe_test\n");
602 aio_md_cleanup(void *arg)
604 struct aio_md_arg *ama;
605 struct md_ioctl mdio;
610 if (ama->ama_fd != -1)
613 if (ama->ama_unit != -1) {
614 bzero(&mdio, sizeof(mdio));
615 mdio.md_version = MDIOVERSION;
616 mdio.md_unit = ama->ama_unit;
617 if (ioctl(ama->ama_mdctl_fd, MDIOCDETACH, &mdio) < 0) {
619 close(ama->ama_mdctl_fd);
621 warnx("FAIL: aio_md_test: MDIOCDETACH: %s",
626 close(ama->ama_mdctl_fd);
629 #define MD_LEN GLOBAL_MAX
630 #define MD_TIMEOUT 30
634 int error, fd, i, mdctl_fd, unit;
635 char pathname[PATH_MAX];
636 struct aio_md_arg arg;
637 struct aio_context ac;
638 struct md_ioctl mdio;
640 mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
642 errx(-1, "FAIL: aio_md_test: open(/dev/%s): %s", MDCTL_NAME,
645 bzero(&mdio, sizeof(mdio));
646 mdio.md_version = MDIOVERSION;
647 mdio.md_type = MD_MALLOC;
648 mdio.md_options = MD_AUTOUNIT | MD_COMPRESS;
649 mdio.md_mediasize = GLOBAL_MAX;
650 mdio.md_sectorsize = 512;
652 arg.ama_mdctl_fd = mdctl_fd;
655 if (ioctl(mdctl_fd, MDIOCATTACH, &mdio) < 0) {
657 aio_md_cleanup(&arg);
659 errx(-1, "FAIL: aio_md_test: MDIOCATTACH: %s",
663 arg.ama_unit = unit = mdio.md_unit;
664 snprintf(pathname, PATH_MAX, "/dev/md%d", unit);
665 fd = open(pathname, O_RDWR);
668 aio_md_cleanup(&arg);
670 errx(-1, "FAIL: aio_md_test: open(%s): %s", pathname,
675 aio_context_init(&ac, "aio_md_test", fd, fd, MD_LEN, MD_TIMEOUT,
676 aio_md_cleanup, &arg);
680 aio_md_cleanup(&arg);
682 fprintf(stderr, "PASS: aio_md_test\n");
686 main(int argc, char *argv[])
692 aio_unix_socketpair_test();
698 fprintf(stderr, "WARNING: aio_md_test: skipped as euid "