Add a basic aio functionality regression test, which simply writes and

then reads from a fairly broad range of object types: regular file,
fifo, UNIX socketpair, pty, UNIX pipe, and an md device.  Not a deep
test of functionality, just a basic test that aio_write followed by
aio_read returns the correct data in a relatively timely manner.

Requested by:	phk

2 files changed, 702 insertions, 0 deletions

diff --git a/tools/regression/aio/aiotest/Makefile b/tools/regression/aio/aiotest/Makefile
new file mode 100644
index 0000000..4b83caf
--- /dev/null
+++ b/tools/regression/aio/aiotest/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+PROG=	aiotest
+NOMAN=	YES
+
+DPADD=	${LIBUTIL}
+LDADD=	-lutil
+
+.include <bsd.prog.mk>
diff --git a/tools/regression/aio/aiotest/aiotest.c b/tools/regression/aio/aiotest/aiotest.c
new file mode 100644
index 0000000..56bc9a0
--- /dev/null
+++ b/tools/regression/aio/aiotest/aiotest.c
@@ -0,0 +1,693 @@
+/*-
+ * Copyright (c) 2004 Robert N. M. Watson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * Regression test to do some very basic AIO exercising on several types of
+ * file descriptors.  Currently, the tests consist of initializing a fixed
+ * size buffer with pseudo-random data, writing it to one fd using AIO, then
+ * reading it from a second descriptor using AIO.  For some targets, the same
+ * fd is used for write and read (i.e., file, md device), but for others the
+ * operation is performed on a peer (pty, socket, fifo, etc).  A timeout is
+ * initiated to detect undo blocking.  This test does not attempt to exercise
+ * error cases or more subtle asynchronous behavior, just make sure that the
+ * basic operations work on some basic object types.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/mdioctl.h>
+
+#include <aio.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include <termios.h>
+#include <unistd.h>
+
+#define	PATH_TEMPLATE	"/tmp/aio.XXXXXXXXXX"
+
+/*
+ * GLOBAL_MAX sets the largest usable buffer size to be read and written, as
+ * it sizes ac_buffer in the aio_context structure.  It is also the default
+ * size for file I/O.  For other types, we use smaller blocks or we risk
+ * blocking (and we run in a single process/thread so that would be bad).
+ */
+#define	GLOBAL_MAX	16384
+
+#define	BUFFER_MAX	GLOBAL_MAX
+struct aio_context {
+	const char	*ac_test;
+	int		 ac_read_fd, ac_write_fd;
+	long		 ac_seed;
+	char		 ac_buffer[GLOBAL_MAX];
+	int		 ac_buflen;
+	int		 ac_seconds;
+	void		 (*ac_cleanup)(void *arg);
+	void		*ac_cleanup_arg;
+};
+
+static int	aio_timedout;
+static int	aio_notpresent;
+
+/*
+ * Attempt to provide a cleaner failure mode in the event AIO support is not
+ * present by catching and reporting SIGSYS.
+ */
+static void
+aio_sigsys(int sig)
+{
+
+	aio_notpresent = 1;
+}
+
+static void
+aio_sigsys_setup(void)
+{
+
+	if (signal(SIGSYS, aio_sigsys) == SIG_ERR)
+		errx(-1, "FAIL: signal(SIGSYS): %s", strerror(errno));
+}
+
+/*
+ * Each test run specifies a timeout in seconds.  Use the somewhat obsoleted
+ * signal(3) and alarm(3) APIs to set this up.
+ */
+static void
+aio_timeout_signal(int sig)
+{
+
+	aio_timedout = 1;
+}
+
+static void
+aio_timeout_start(const char *string1, const char *string2, int seconds)
+{
+
+	aio_timedout = 0;
+	if (signal(SIGALRM, aio_timeout_signal) == SIG_ERR)
+		errx(-1, "FAIL: %s: %s: aio_timeout_set: signal(SIGALRM): %s",
+		    string1, string2, strerror(errno));
+	alarm(seconds);
+}
+
+static void
+aio_timeout_stop(const char *string1, const char *string2)
+{
+
+	if (signal(SIGALRM, NULL) == SIG_ERR)
+		errx(-1, "FAIL: %s: %s: aio_timeout_stop: signal(NULL): %s",
+		    string1, string2, strerror(errno));
+	alarm(0);
+}
+
+/*
+ * Fill a buffer given a seed that can be fed into srandom() to initialize
+ * the PRNG in a repeatable manner.
+ */
+static void
+aio_fill_buffer(char *buffer, int len, long seed)
+{
+	char ch;
+	int i;
+
+	srandom(seed);
+	for (i = 0; i < len; i++) {
+		ch = random() & 0xff;
+		buffer[i] = ch;
+	}
+}
+
+/*
+ * Test that a buffer matches a given seed.  See aio_fill_buffer().  Return
+ * (1) on a match, (0) on a mismatch.
+ */
+static int
+aio_test_buffer(char *buffer, int len, long seed)
+{
+	char ch;
+	int i;
+
+	srandom(seed);
+	for (i = 0; i < len; i++) {
+		ch = random() & 0xff;
+		if (buffer[i] != ch)
+			return (0);
+	}
+	return (1);
+}
+
+/*
+ * Initialize a testing context given the file descriptors provided by the
+ * test setup.
+ */
+static void
+aio_context_init(struct aio_context *ac, const char *test, int read_fd,
+    int write_fd, int buflen, int seconds, void (*cleanup)(void *),
+    void *cleanup_arg)
+{
+
+	if (buflen > BUFFER_MAX)
+		errx(-1, "FAIL: %s: aio_context_init: buffer too large",
+		    test);
+	bzero(ac, sizeof(*ac));
+	ac->ac_test = test;
+	ac->ac_read_fd = read_fd;
+	ac->ac_write_fd = write_fd;
+	ac->ac_buflen = buflen;
+	srandomdev();
+	ac->ac_seed = random();
+	aio_fill_buffer(ac->ac_buffer, buflen, ac->ac_seed);
+	if (aio_test_buffer(ac->ac_buffer, buflen, ac->ac_seed) == 0)
+		errx(-1, "%s: aio_context_init: aio_test_buffer: internal "
+		    "error", test);
+	ac->ac_seconds = seconds;
+	ac->ac_cleanup = cleanup;
+	ac->ac_cleanup_arg = cleanup_arg;
+}
+
+/*
+ * Each tester can register a callback to clean up in the event the test
+ * fails.  Preserve the value of errno so that subsequent calls to errx()
+ * work properly.
+ */
+static void
+aio_cleanup(struct aio_context *ac)
+{
+	int error;
+
+	if (ac->ac_cleanup == NULL)
+		return;
+	error = errno;
+	(ac->ac_cleanup)(ac->ac_cleanup_arg);
+	errno = error;
+}
+
+/*
+ * Perform a simple write test of our initialized data buffer to the provided
+ * file descriptor.
+ */
+static void
+aio_write_test(struct aio_context *ac)
+{
+	struct aiocb aio, *aiop;
+	ssize_t len;
+	int error;
+
+	bzero(&aio, sizeof(aio));
+	aio.aio_buf = ac->ac_buffer;
+	aio.aio_nbytes = ac->ac_buflen;
+	aio.aio_fildes = ac->ac_write_fd;
+	aio.aio_offset = 0;
+
+	aio_timeout_start(ac->ac_test, "aio_write_test", ac->ac_seconds);
+
+	if (aio_write(&aio) < 0) {
+		if (errno == EINTR) {
+			if (aio_notpresent)
+				errno = EOPNOTSUPP;
+			if (aio_timedout) {
+				aio_cleanup(ac);
+				errx(-1, "FAIL: %s: aio_write_test: "
+				    "aio_write: timed out", ac->ac_test);
+			}
+		}
+		aio_cleanup(ac);
+		errx(-1, "FAIL: %s: aio_write_test: aio_write: %s",
+		    ac->ac_test, strerror(errno));
+	}
+
+	len = aio_waitcomplete(&aiop, NULL);
+	if (len < 0) {
+		if (errno == EINTR) {
+			if (aio_notpresent)
+				errno = EOPNOTSUPP;
+			if (aio_timedout) {
+				aio_cleanup(ac);
+				errx(-1, "FAIL: %s: aio_write_test: "
+				    "aio_waitcomplete: timed out",
+				    ac->ac_test);
+			}
+		}
+		aio_cleanup(ac);
+		errx(-1, "FAIL: %s: aio_write_test: aio_waitcomplete: %s",
+		    ac->ac_test, strerror(errno));
+	}
+
+	aio_timeout_stop(ac->ac_test, "aio_write_test");
+
+	if (len != ac->ac_buflen) {
+		aio_cleanup(ac);
+		errx(-1, "FAIL: %s: aio_write_test: aio_waitcomplete: short "
+		    "write (%d)", ac->ac_test, len);
+	}
+}
+
+/*
+ * Perform a simple read test of our initialized data buffer from the
+ * provided file descriptor.
+ */
+static void
+aio_read_test(struct aio_context *ac)
+{
+	struct aiocb aio, *aiop;
+	ssize_t len;
+
+	bzero(ac->ac_buffer, ac->ac_buflen);
+	bzero(&aio, sizeof(aio));
+	aio.aio_buf = ac->ac_buffer;
+	aio.aio_nbytes = ac->ac_buflen;
+	aio.aio_fildes = ac->ac_read_fd;
+	aio.aio_offset = 0;
+
+	aio_timeout_start(ac->ac_test, "aio_read_test", ac->ac_seconds);
+
+	if (aio_read(&aio) < 0) {
+		if (errno == EINTR) {
+			if (aio_notpresent)
+				errno = EOPNOTSUPP;
+			if (aio_timedout) {
+				aio_cleanup(ac);
+				errx(-1, "FAIL: %s: aio_read_test: "
+				    "aio_read: timed out", ac->ac_test);
+			}
+		}
+		aio_cleanup(ac);
+		errx(-1, "FAIL: %s: aio_read_test: aio_read %s", ac->ac_test,
+		    strerror(errno));
+	}
+
+	len = aio_waitcomplete(&aiop, NULL);
+	if (len < 0) {
+		if (errno == EINTR) {
+			if (aio_notpresent)
+				errno = EOPNOTSUPP;
+			if (aio_timedout) {
+				aio_cleanup(ac);
+				errx(-1, "FAIL: %s: aio_read_test: "
+				    "aio_waitcomplete: timed out",
+				    ac->ac_test);
+			}
+		}
+		aio_cleanup(ac);
+		errx(-1, "FAIL: %s: aio_read_test: aio_waitcomplete: %s",
+		    ac->ac_test, strerror(errno));
+	}
+
+	aio_timeout_stop(ac->ac_test, "aio_read_test");
+
+	if (len != ac->ac_buflen) {
+		aio_cleanup(ac);
+		errx(-1, "FAIL: %s: aio_read_test: aio_waitcomplete: short "
+		    "read (%d)", ac->ac_test, len);
+	}
+
+	if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0) {
+		aio_cleanup(ac);
+		errx(-1, "FAIL: %s: aio_read_test: buffer mismatch",
+		    ac->ac_test);
+	}
+}
+
+/*
+ * Series of type-specific tests for AIO.  For now, we just make sure we can
+ * issue a write and then a read to each type.  We assume that once a write
+ * is issued, a read can follow.
+ */
+
+/*
+ * Test with a classic file.  Assumes we can create a moderate size temporary
+ * file.
+ */
+struct aio_file_arg {
+	int	 afa_fd;
+	char	*afa_pathname;
+};
+
+static void
+aio_file_cleanup(void *arg)
+{
+	struct aio_file_arg *afa;
+
+	afa = arg;
+	close(afa->afa_fd);
+	unlink(afa->afa_pathname);
+}
+
+#define	FILE_LEN	GLOBAL_MAX
+#define	FILE_TIMEOUT	30
+static int
+aio_file_test(void)
+{
+	char pathname[PATH_MAX];
+	struct aio_file_arg arg;
+	struct aio_context ac;
+	int fd;
+
+	strcpy(pathname, PATH_TEMPLATE);
+	fd = mkstemp(pathname);
+	if (fd == -1)
+		errx(-1, "FAIL: aio_file_test: mkstemp: %s",
+		    strerror(errno));
+
+	arg.afa_fd = fd;
+	arg.afa_pathname = pathname;
+
+	aio_context_init(&ac, "aio_file_test", fd, fd, FILE_LEN,
+	    FILE_TIMEOUT, aio_file_cleanup, &arg);
+	aio_write_test(&ac);
+	aio_read_test(&ac);
+
+	aio_file_cleanup(&arg);
+	
+	fprintf(stderr, "PASS: aio_file_test\n");
+}
+
+struct aio_fifo_arg {
+	int	 afa_read_fd;
+	int	 afa_write_fd;
+	char	*afa_pathname;
+};
+
+static void
+aio_fifo_cleanup(void *arg)
+{
+	struct aio_fifo_arg *afa;
+
+	afa = arg;
+	if (afa->afa_read_fd != -1)
+		close(afa->afa_read_fd);
+	if (afa->afa_write_fd != -1)
+		close(afa->afa_write_fd);
+	unlink(afa->afa_pathname);
+}
+
+#define	FIFO_LEN	256
+#define	FIFO_TIMEOUT	30
+static int
+aio_fifo_test(void)
+{
+	int error, read_fd = -1, write_fd = -1;
+	struct aio_fifo_arg arg;
+	char pathname[PATH_MAX];
+	struct aio_context ac;
+
+	/*
+	 * In theory, mktemp() can return a name that is then collided with.
+	 * Because this is a regression test, we treat that as a test failure
+	 * rather than retrying.
+	 */
+	strcpy(pathname, PATH_TEMPLATE);
+	mktemp(pathname);
+	if (mkfifo(pathname, 0600) == -1)
+		errx(-1, "FAIL: aio_fifo_test: mkfifo: %s", strerror(errno));
+	arg.afa_pathname = pathname;
+	arg.afa_read_fd = -1;
+	arg.afa_write_fd = -1;
+
+	read_fd = open(pathname, O_RDONLY | O_NONBLOCK);
+	if (read_fd == -1) {
+		error = errno;
+		aio_fifo_cleanup(&arg);
+		errno = error;
+		errx(-1, "FAIL: aio_fifo_test: read_fd open: %s",
+		    strerror(errno));
+	}
+	arg.afa_read_fd = read_fd;
+
+	write_fd = open(pathname, O_WRONLY);
+	if (write_fd == -1) {
+		error = errno;
+		aio_fifo_cleanup(&arg);
+		errno = error;
+		errx(-1, "FAIL: aio_fifo_test: write_fd open: %s",
+		    strerror(errno));
+	}
+	arg.afa_write_fd = write_fd;
+
+	aio_context_init(&ac, "aio_fifo_test", read_fd, write_fd, FIFO_LEN,
+	    FIFO_TIMEOUT, aio_fifo_cleanup, &arg);
+	aio_write_test(&ac);
+	aio_read_test(&ac);
+
+	aio_fifo_cleanup(&arg);
+
+	fprintf(stderr, "PASS: aio_fifo_test\n");
+}
+
+struct aio_unix_socketpair_arg {
+	int	asa_sockets[2];
+};
+
+static void
+aio_unix_socketpair_cleanup(void *arg)
+{
+	struct aio_unix_socketpair_arg *asa;
+
+	asa = arg;
+	close(asa->asa_sockets[0]);
+	close(asa->asa_sockets[1]);
+}
+
+#define	UNIX_SOCKETPAIR_LEN	256
+#define	UNIX_SOCKETPAIR_TIMEOUT	30
+static int
+aio_unix_socketpair_test(void)
+{
+	struct aio_unix_socketpair_arg arg;
+	struct aio_context ac;
+	int sockets[2];
+
+	if (socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) < 0)
+		errx(-1, "FAIL: aio_socketpair_test: socketpair: %s",
+		    strerror(errno));
+
+	arg.asa_sockets[0] = sockets[0];
+	arg.asa_sockets[1] = sockets[1];
+	aio_context_init(&ac, "aio_unix_socketpair_test", sockets[0],
+	    sockets[1], UNIX_SOCKETPAIR_LEN, UNIX_SOCKETPAIR_TIMEOUT,
+	    aio_unix_socketpair_cleanup, &arg);
+	aio_write_test(&ac);
+	aio_read_test(&ac);
+
+	aio_unix_socketpair_cleanup(&arg);
+
+	fprintf(stderr, "PASS: aio_unix_socketpair_test\n");
+}
+
+struct aio_pty_arg {
+	int	apa_read_fd;
+	int	apa_write_fd;
+};
+
+static void
+aio_pty_cleanup(void *arg)
+{
+	struct aio_pty_arg *apa;
+
+	close(apa->apa_read_fd);
+	close(apa->apa_write_fd);
+};
+
+#define	PTY_LEN		256
+#define	PTY_TIMEOUT	30
+static int
+aio_pty_test(void)
+{
+	struct aio_pty_arg arg;
+	struct aio_context ac;
+	int read_fd, write_fd;
+	struct termios ts;
+	int error;
+
+	if (openpty(&read_fd, &write_fd, NULL, NULL, NULL) < 0)
+		errx(-1, "FAIL: aio_pty_test: openpty: %s", strerror(errno));
+
+	arg.apa_read_fd = read_fd;
+	arg.apa_write_fd = write_fd;
+
+	if (tcgetattr(write_fd, &ts) < 0) {
+		error = errno;
+		aio_pty_cleanup(&arg);
+		errno = error;
+		errx(-1, "FAIL: aio_pty_test: tcgetattr: %s",
+		    strerror(errno));
+	}
+	cfmakeraw(&ts);
+	if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
+		error = errno;
+		aio_pty_cleanup(&arg);
+		errno = error;
+		errx(-1, "FAIL: aio_pty_test: tcsetattr: %s",
+		    strerror(errno));
+	}
+
+	aio_context_init(&ac, "aio_pty_test", read_fd, write_fd, PTY_LEN,
+	    PTY_TIMEOUT, aio_pty_cleanup, &arg);
+	aio_write_test(&ac);
+	aio_read_test(&ac);
+
+	aio_pty_cleanup(&arg);
+
+	fprintf(stderr, "PASS: aio_pty_test\n");
+}
+
+static void
+aio_pipe_cleanup(void *arg)
+{
+	int *pipes = arg;
+
+	close(pipes[0]);
+	close(pipes[1]);
+}
+
+#define	PIPE_LEN	256
+#define	PIPE_TIMEOUT	30
+static int
+aio_pipe_test(void)
+{	
+	struct aio_context ac;
+	int pipes[2];
+
+	if (pipe(pipes) < 0)
+		errx(-1, "FAIL: aio_pipe_test: pipe: %s", strerror(errno));
+
+	aio_context_init(&ac, "aio_file_test", pipes[0], pipes[1], PIPE_LEN,
+	    PIPE_TIMEOUT, aio_pipe_cleanup, pipes);
+	aio_write_test(&ac);
+	aio_read_test(&ac);
+
+	aio_pipe_cleanup(pipes);
+
+	fprintf(stderr, "PASS: aio_pipe_test\n");
+}
+
+struct aio_md_arg {
+	int	ama_mdctl_fd;
+	int	ama_unit;
+	int	ama_fd;
+};
+
+static void
+aio_md_cleanup(void *arg)
+{
+	struct aio_md_arg *ama;
+	struct md_ioctl mdio;
+	int error;
+
+	ama = arg;
+
+	if (ama->ama_fd != -1)
+		close(ama->ama_fd);
+
+	if (ama->ama_unit != -1) {
+		bzero(&mdio, sizeof(mdio));
+		mdio.md_version = MDIOVERSION;
+		mdio.md_unit = ama->ama_unit;
+		if (ioctl(ama->ama_mdctl_fd, MDIOCDETACH, &mdio) < 0) {
+			error = errno;
+			close(ama->ama_mdctl_fd);
+			errno = error;
+			warnx("FAIL: aio_md_test: MDIOCDETACH: %s",
+			    strerror(errno));
+		}
+	}
+
+	close(ama->ama_mdctl_fd);
+}
+
+#define	MD_LEN		GLOBAL_MAX
+#define	MD_TIMEOUT	30
+static int
+aio_md_test(void)
+{
+	int error, fd, i, mdctl_fd, unit;
+	char pathname[PATH_MAX];
+	struct aio_md_arg arg;
+	struct aio_context ac;
+	struct md_ioctl mdio;
+
+	mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
+	if (mdctl_fd < 0)
+		errx(-1, "FAIL: aio_md_test: open(/dev/%s): %s", MDCTL_NAME,
+		    strerror(errno));
+
+	bzero(&mdio, sizeof(mdio));
+	mdio.md_version = MDIOVERSION;
+	mdio.md_type = MD_MALLOC;
+	mdio.md_options = MD_AUTOUNIT | MD_COMPRESS;
+	mdio.md_mediasize = GLOBAL_MAX;
+	mdio.md_sectorsize = 512;
+
+	arg.ama_mdctl_fd = mdctl_fd;
+	arg.ama_unit = -1;
+	arg.ama_fd = -1;
+	if (ioctl(mdctl_fd, MDIOCATTACH, &mdio) < 0) {
+		error = errno;
+		aio_md_cleanup(&arg);
+		errno = error;
+		errx(-1, "FAIL: aio_md_test: MDIOCATTACH: %s",
+		    strerror(errno));
+	}
+
+	arg.ama_unit = unit = mdio.md_unit;
+	snprintf(pathname, PATH_MAX, "/dev/md%d", unit);
+	fd = open(pathname, O_RDWR);
+	if (fd < 0) {
+		error = errno;
+		aio_md_cleanup(&arg);
+		errno = error;
+		errx(-1, "FAIL: aio_md_test: open(%s): %s", pathname,
+		    strerror(errno));
+	}
+	arg.ama_fd = fd;
+
+	aio_context_init(&ac, "aio_md_test", fd, fd, MD_LEN, MD_TIMEOUT,
+	    aio_md_cleanup, &arg);
+	aio_write_test(&ac);
+	aio_read_test(&ac);
+
+	aio_md_cleanup(&arg);
+
+	fprintf(stderr, "PASS: aio_md_test\n");
+}
+
+int
+main(int argc, char *argv[])
+{
+
+	aio_sigsys_setup();
+	aio_file_test();
+	aio_fifo_test();
+	aio_unix_socketpair_test();
+	aio_pty_test();
+	aio_pipe_test();
+	aio_md_test();
+}