D11468.diff
No OneTemporary
Actions

Size

14 KB

Referenced Files

None

Subscribers

None

D11468.diff
View Options

	Index: head/tests/sys/aio/Makefile
	===================================================================
	--- head/tests/sys/aio/Makefile
	+++ head/tests/sys/aio/Makefile
	@@ -3,11 +3,12 @@
	TESTSDIR= ${TESTSBASE}/sys/aio

	ATF_TESTS_C+= aio_test
	+TEST_METADATA.aio_test+= timeout="30"

	PLAIN_TESTS_C+= aio_kqueue_test
	PLAIN_TESTS_C+= lio_kqueue_test

	-LIBADD.aio_test+= util
	+LIBADD.aio_test+= util rt

	CFLAGS+= -I${.CURDIR:H:H}

	Index: head/tests/sys/aio/aio_test.c
	===================================================================
	--- head/tests/sys/aio/aio_test.c
	+++ head/tests/sys/aio/aio_test.c
	@@ -32,10 +32,11 @@
	* 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 undue 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.
	+ * operation is performed on a peer (pty, socket, fifo, etc). For each file
	+ * descriptor type, several completion methods are tested. This test program
	+ * 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/param.h>
	@@ -85,43 +86,10 @@
	char ac_buffer[GLOBAL_MAX];
	int ac_buflen;
	int ac_seconds;
	- void (ac_cleanup)(void arg);
	- void *ac_cleanup_arg;
	};

	-static int aio_timedout;

	/*
	- * 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 __unused)
	-{
	-
	- aio_timedout = 1;
	-}
	-
	-static void
	-aio_timeout_start(int seconds)
	-{
	-
	- aio_timedout = 0;
	- ATF_REQUIRE_MSG(signal(SIGALRM, aio_timeout_signal) != SIG_ERR,
	- "failed to set SIGALRM handler: %s", strerror(errno));
	- alarm(seconds);
	-}
	-
	-static void
	-aio_timeout_stop(void)
	-{
	-
	- ATF_REQUIRE_MSG(signal(SIGALRM, NULL) != SIG_ERR,
	- "failed to reset SIGALRM handler to default: %s", strerror(errno));
	- alarm(0);
	-}
	-
	-/*
	* Fill a buffer given a seed that can be fed into srandom() to initialize
	* the PRNG in a repeatable manner.
	*/
	@@ -163,8 +131,7 @@
	*/
	static void
	aio_context_init(struct aio_context *ac, int read_fd,
	- int write_fd, int buflen, int seconds, void (cleanup)(void ),
	- void *cleanup_arg)
	+ int write_fd, int buflen)
	{

	ATF_REQUIRE_MSG(buflen <= BUFFER_MAX,
	@@ -179,9 +146,6 @@
	aio_fill_buffer(ac->ac_buffer, buflen, ac->ac_seed);
	ATF_REQUIRE_MSG(aio_test_buffer(ac->ac_buffer, buflen,
	ac->ac_seed) != 0, "aio_test_buffer: internal error");
	- ac->ac_seconds = seconds;
	- ac->ac_cleanup = cleanup;
	- ac->ac_cleanup_arg = cleanup_arg;
	}

	static ssize_t
	@@ -189,7 +153,7 @@
	{
	int error;

	- while ((error = aio_error(aio)) == EINPROGRESS && !aio_timedout)
	+ while ((error = aio_error(aio)) == EINPROGRESS)
	usleep(25000);
	switch (error) {
	case EINPROGRESS:
	@@ -227,23 +191,6 @@
	}

	/*
	- * 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.
	*/
	@@ -259,37 +206,15 @@
	aio.aio_fildes = ac->ac_write_fd;
	aio.aio_offset = 0;

	- aio_timeout_start(ac->ac_seconds);
	-
	- if (aio_write(&aio) < 0) {
	- if (errno == EINTR) {
	- if (aio_timedout) {
	- aio_cleanup(ac);
	- atf_tc_fail("aio_write timed out");
	- }
	- }
	- aio_cleanup(ac);
	+ if (aio_write(&aio) < 0)
	atf_tc_fail("aio_write failed: %s", strerror(errno));
	- }

	len = comp(&aio);
	- if (len < 0) {
	- if (errno == EINTR) {
	- if (aio_timedout) {
	- aio_cleanup(ac);
	- atf_tc_fail("aio timed out");
	- }
	- }
	- aio_cleanup(ac);
	+ if (len < 0)
	atf_tc_fail("aio failed: %s", strerror(errno));
	- }

	- aio_timeout_stop();
	-
	- if (len != ac->ac_buflen) {
	- aio_cleanup(ac);
	+ if (len != ac->ac_buflen)
	atf_tc_fail("aio short write (%jd)", (intmax_t)len);
	- }
	}

	/*
	@@ -309,43 +234,18 @@
	aio.aio_fildes = ac->ac_read_fd;
	aio.aio_offset = 0;

	- aio_timeout_start(ac->ac_seconds);
	-
	- if (aio_read(&aio) < 0) {
	- if (errno == EINTR) {
	- if (aio_timedout) {
	- aio_cleanup(ac);
	- atf_tc_fail("aio_read timed out");
	- }
	- }
	- aio_cleanup(ac);
	+ if (aio_read(&aio) < 0)
	atf_tc_fail("aio_read failed: %s", strerror(errno));
	- }

	len = comp(&aio);
	- if (len < 0) {
	- if (errno == EINTR) {
	- if (aio_timedout) {
	- aio_cleanup(ac);
	- atf_tc_fail("aio timed out");
	- }
	- }
	- aio_cleanup(ac);
	+ if (len < 0)
	atf_tc_fail("aio failed: %s", strerror(errno));
	- }

	- aio_timeout_stop();
	+ ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
	+ "aio short read (%jd)", (intmax_t)len);

	- if (len != ac->ac_buflen) {
	- aio_cleanup(ac);
	- atf_tc_fail("aio short read (%jd)",
	- (intmax_t)len);
	- }
	-
	- if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0) {
	- aio_cleanup(ac);
	+ if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
	atf_tc_fail("buffer mismatched");
	- }
	}

	/*
	@@ -360,25 +260,10 @@
	*/
	#define FILE_LEN GLOBAL_MAX
	#define FILE_PATHNAME "testfile"
	-#define FILE_TIMEOUT 30
	-struct aio_file_arg {
	- int afa_fd;
	-};

	static void
	-aio_file_cleanup(void *arg)
	-{
	- struct aio_file_arg *afa;
	-
	- afa = arg;
	- close(afa->afa_fd);
	- unlink(FILE_PATHNAME);
	-}
	-
	-static void
	aio_file_test(completion comp)
	{
	- struct aio_file_arg arg;
	struct aio_context ac;
	int fd;

	@@ -388,14 +273,10 @@
	fd = open(FILE_PATHNAME, O_RDWR \| O_CREAT, 0600);
	ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));

	- arg.afa_fd = fd;
	-
	- aio_context_init(&ac, fd, fd, FILE_LEN,
	- FILE_TIMEOUT, aio_file_cleanup, &arg);
	+ aio_context_init(&ac, fd, fd, FILE_LEN);
	aio_write_test(&ac, comp);
	aio_read_test(&ac, comp);
	-
	- aio_file_cleanup(&arg);
	+ close(fd);
	}

	ATF_TC_WITHOUT_HEAD(file_poll);
	@@ -418,30 +299,11 @@

	#define FIFO_LEN 256
	#define FIFO_PATHNAME "testfifo"
	-#define FIFO_TIMEOUT 30
	-struct aio_fifo_arg {
	- int afa_read_fd;
	- int afa_write_fd;
	-};

	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(FIFO_PATHNAME);
	-}
	-
	-static void
	aio_fifo_test(completion comp)
	{
	int error, read_fd = -1, write_fd = -1;
	- struct aio_fifo_arg arg;
	struct aio_context ac;

	ATF_REQUIRE_KERNEL_MODULE("aio");
	@@ -449,35 +311,29 @@

	ATF_REQUIRE_MSG(mkfifo(FIFO_PATHNAME, 0600) != -1,
	"mkfifo failed: %s", strerror(errno));
	- arg.afa_read_fd = -1;
	- arg.afa_write_fd = -1;

	read_fd = open(FIFO_PATHNAME, O_RDONLY \| O_NONBLOCK);
	if (read_fd == -1) {
	error = errno;
	- aio_fifo_cleanup(&arg);
	errno = error;
	atf_tc_fail("read_fd open failed: %s",
	strerror(errno));
	}
	- arg.afa_read_fd = read_fd;

	write_fd = open(FIFO_PATHNAME, O_WRONLY);
	if (write_fd == -1) {
	error = errno;
	- aio_fifo_cleanup(&arg);
	errno = error;
	atf_tc_fail("write_fd open failed: %s",
	strerror(errno));
	}
	- arg.afa_write_fd = write_fd;

	- aio_context_init(&ac, read_fd, write_fd, FIFO_LEN,
	- FIFO_TIMEOUT, aio_fifo_cleanup, &arg);
	+ aio_context_init(&ac, read_fd, write_fd, FIFO_LEN);
	aio_write_test(&ac, comp);
	aio_read_test(&ac, comp);

	- aio_fifo_cleanup(&arg);
	+ close(read_fd);
	+ close(write_fd);
	}

	ATF_TC_WITHOUT_HEAD(fifo_poll);
	@@ -489,7 +345,7 @@
	ATF_TC_WITHOUT_HEAD(fifo_suspend);
	ATF_TC_BODY(fifo_suspend, tc)
	{
	- aio_fifo_test(waitcomplete);
	+ aio_fifo_test(suspend);
	}

	ATF_TC_WITHOUT_HEAD(fifo_waitcomplete);
	@@ -498,26 +354,10 @@
	aio_fifo_test(waitcomplete);
	}

	-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 void
	aio_unix_socketpair_test(completion comp)
	{
	- struct aio_unix_socketpair_arg arg;
	struct aio_context ac;
	struct rusage ru_before, ru_after;
	int sockets[2];
	@@ -527,11 +367,7 @@
	ATF_REQUIRE_MSG(socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) != -1,
	"socketpair failed: %s", strerror(errno));

	- arg.asa_sockets[0] = sockets[0];
	- arg.asa_sockets[1] = sockets[1];
	- aio_context_init(&ac, sockets[0],
	- sockets[1], UNIX_SOCKETPAIR_LEN, UNIX_SOCKETPAIR_TIMEOUT,
	- aio_unix_socketpair_cleanup, &arg);
	+ aio_context_init(&ac, sockets[0], sockets[1], UNIX_SOCKETPAIR_LEN);
	ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_before) != -1,
	"getrusage failed: %s", strerror(errno));
	aio_write_test(&ac, comp);
	@@ -544,7 +380,8 @@
	"getrusage failed: %s", strerror(errno));
	ATF_REQUIRE(ru_after.ru_msgrcv == ru_before.ru_msgrcv + 1);

	- aio_unix_socketpair_cleanup(&arg);
	+ close(sockets[0]);
	+ close(sockets[1]);
	}

	ATF_TC_WITHOUT_HEAD(socket_poll);
	@@ -570,22 +407,10 @@
	int apa_write_fd;
	};

	-static void
	-aio_pty_cleanup(void *arg)
	-{
	- struct aio_pty_arg *apa;
	-
	- apa = arg;
	- close(apa->apa_read_fd);
	- close(apa->apa_write_fd);
	-};
	-
	#define PTY_LEN 256
	-#define PTY_TIMEOUT 30
	static void
	aio_pty_test(completion comp)
	{
	- struct aio_pty_arg arg;
	struct aio_context ac;
	int read_fd, write_fd;
	struct termios ts;
	@@ -597,29 +422,25 @@
	ATF_REQUIRE_MSG(openpty(&read_fd, &write_fd, NULL, NULL, NULL) == 0,
	"openpty failed: %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;
	atf_tc_fail("tcgetattr failed: %s", strerror(errno));
	}
	cfmakeraw(&ts);
	if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
	error = errno;
	- aio_pty_cleanup(&arg);
	errno = error;
	atf_tc_fail("tcsetattr failed: %s", strerror(errno));
	}
	- aio_context_init(&ac, read_fd, write_fd, PTY_LEN,
	- PTY_TIMEOUT, aio_pty_cleanup, &arg);
	+ aio_context_init(&ac, read_fd, write_fd, PTY_LEN);

	aio_write_test(&ac, comp);
	aio_read_test(&ac, comp);

	- aio_pty_cleanup(&arg);
	+ close(read_fd);
	+ close(write_fd);
	}

	ATF_TC_WITHOUT_HEAD(pty_poll);
	@@ -640,17 +461,7 @@
	aio_pty_test(waitcomplete);
	}

	-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 void
	aio_pipe_test(completion comp)
	{
	@@ -663,12 +474,12 @@
	ATF_REQUIRE_MSG(pipe(pipes) != -1,
	"pipe failed: %s", strerror(errno));

	- aio_context_init(&ac, pipes[0], pipes[1], PIPE_LEN,
	- PIPE_TIMEOUT, aio_pipe_cleanup, pipes);
	+ aio_context_init(&ac, pipes[0], pipes[1], PIPE_LEN);
	aio_write_test(&ac, comp);
	aio_read_test(&ac, comp);

	- aio_pipe_cleanup(pipes);
	+ close(pipes[0]);
	+ close(pipes[1]);
	}

	ATF_TC_WITHOUT_HEAD(pipe_poll);
	@@ -689,50 +500,45 @@
	aio_pipe_test(waitcomplete);
	}

	-struct aio_md_arg {
	- int ama_mdctl_fd;
	- int ama_unit;
	- int ama_fd;
	-};
	+#define MD_LEN GLOBAL_MAX
	+#define MDUNIT_LINK "mdunit_link"

	static void
	-aio_md_cleanup(void *arg)
	+aio_md_cleanup(void)
	{
	- struct aio_md_arg *ama;
	struct md_ioctl mdio;
	- int error;
	+ int mdctl_fd, error, n, unit;
	+ char buf[80];

	- 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) == -1) {
	- error = errno;
	- close(ama->ama_mdctl_fd);
	- errno = error;
	- atf_tc_fail("ioctl MDIOCDETACH failed: %s",
	- strerror(errno));
	+ mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
	+ ATF_REQUIRE(mdctl_fd >= 0);
	+ n = readlink(MDUNIT_LINK, buf, sizeof(buf));
	+ if (n > 0) {
	+ if (sscanf(buf, "%d", &unit) == 1 && unit >= 0) {
	+ bzero(&mdio, sizeof(mdio));
	+ mdio.md_version = MDIOVERSION;
	+ mdio.md_unit = unit;
	+ if (ioctl(mdctl_fd, MDIOCDETACH, &mdio) == -1) {
	+ error = errno;
	+ close(mdctl_fd);
	+ errno = error;
	+ atf_tc_fail("ioctl MDIOCDETACH failed: %s",
	+ strerror(errno));
	+ }
	}
	}
	-
	- close(ama->ama_mdctl_fd);
	+
	+ close(mdctl_fd);
	}

	-#define MD_LEN GLOBAL_MAX
	-#define MD_TIMEOUT 30
	static void
	aio_md_test(completion comp)
	{
	int error, fd, mdctl_fd, unit;
	char pathname[PATH_MAX];
	- struct aio_md_arg arg;
	struct aio_context ac;
	struct md_ioctl mdio;
	+ char buf[80];

	ATF_REQUIRE_KERNEL_MODULE("aio");
	ATF_REQUIRE_UNSAFE_AIO();
	@@ -748,32 +554,30 @@
	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;
	atf_tc_fail("ioctl MDIOCATTACH failed: %s", strerror(errno));
	}
	+ close(mdctl_fd);

	- arg.ama_unit = unit = mdio.md_unit;
	+ /* Store the md unit number in a symlink for future cleanup */
	+ unit = mdio.md_unit;
	+ snprintf(buf, sizeof(buf), "%d", unit);
	+ ATF_REQUIRE_EQ(0, symlink(buf, MDUNIT_LINK));
	snprintf(pathname, PATH_MAX, "/dev/md%d", unit);
	fd = open(pathname, O_RDWR);
	ATF_REQUIRE_MSG(fd != -1,
	"opening %s failed: %s", pathname, strerror(errno));
	- arg.ama_fd = fd;

	- aio_context_init(&ac, fd, fd, MD_LEN, MD_TIMEOUT,
	- aio_md_cleanup, &arg);
	+ aio_context_init(&ac, fd, fd, MD_LEN);
	aio_write_test(&ac, comp);
	aio_read_test(&ac, comp);
	-
	- aio_md_cleanup(&arg);
	+
	+ close(fd);
	}

	-ATF_TC(md_poll);
	+ATF_TC_WITH_CLEANUP(md_poll);
	ATF_TC_HEAD(md_poll, tc)
	{

	@@ -783,8 +587,12 @@
	{
	aio_md_test(poll);
	}
	+ATF_TC_CLEANUP(md_poll, tc)
	+{
	+ aio_md_cleanup();
	+}

	-ATF_TC(md_suspend);
	+ATF_TC_WITH_CLEANUP(md_suspend);
	ATF_TC_HEAD(md_suspend, tc)
	{

	@@ -794,8 +602,12 @@
	{
	aio_md_test(suspend);
	}
	+ATF_TC_CLEANUP(md_suspend, tc)
	+{
	+ aio_md_cleanup();
	+}

	-ATF_TC(md_waitcomplete);
	+ATF_TC_WITH_CLEANUP(md_waitcomplete);
	ATF_TC_HEAD(md_waitcomplete, tc)
	{

	@@ -804,6 +616,10 @@
	ATF_TC_BODY(md_waitcomplete, tc)
	{
	aio_md_test(waitcomplete);
	+}
	+ATF_TC_CLEANUP(md_waitcomplete, tc)
	+{
	+ aio_md_cleanup();
	}

	ATF_TC_WITHOUT_HEAD(aio_large_read_test);

File Metadata

Mime Type: text/plain
Expires: Tue, Feb 4, 10:52 PM (21 h, 2 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 16462479
Default Alt Text: D11468.diff (14 KB)

D11468.diffNo OneTemporaryActions

D11468.diffView Options

File Metadata

Event Timeline

D11468.diff
No OneTemporary
Actions

D11468.diff
View Options