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
28 * Regression test to do some very basic AIO exercising on several types of
29 * file descriptors. Currently, the tests consist of initializing a fixed
30 * size buffer with pseudo-random data, writing it to one fd using AIO, then
31 * reading it from a second descriptor using AIO. For some targets, the same
32 * fd is used for write and read (i.e., file, md device), but for others the
33 * operation is performed on a peer (pty, socket, fifo, etc). For each file
34 * descriptor type, several completion methods are tested. This test program
35 * does not attempt to exercise error cases or more subtle asynchronous
36 * behavior, just make sure that the basic operations work on some basic object
40 #include <sys/param.h>
41 #include <sys/event.h>
42 #include <sys/mdioctl.h>
43 #include <sys/module.h>
44 #include <sys/resource.h>
45 #include <sys/socket.h>
55 #include <semaphore.h>
66 #include "freebsd_test_suite/macros.h"
70 * GLOBAL_MAX sets the largest usable buffer size to be read and written, as
71 * it sizes ac_buffer in the aio_context structure. It is also the default
72 * size for file I/O. For other types, we use smaller blocks or we risk
73 * blocking (and we run in a single process/thread so that would be bad).
75 #define GLOBAL_MAX 16384
77 #define BUFFER_MAX GLOBAL_MAX
80 * A completion function will block until the aio has completed, then return
81 * the result of the aio. errno will be set appropriately.
83 typedef ssize_t (*completion)(struct aiocb*);
86 int ac_read_fd, ac_write_fd;
88 char ac_buffer[GLOBAL_MAX];
93 static sem_t completions;
96 * Fill a buffer given a seed that can be fed into srandom() to initialize
97 * the PRNG in a repeatable manner.
100 aio_fill_buffer(char *buffer, int len, long seed)
106 for (i = 0; i < len; i++) {
107 ch = random() & 0xff;
113 * Test that a buffer matches a given seed. See aio_fill_buffer(). Return
114 * (1) on a match, (0) on a mismatch.
117 aio_test_buffer(char *buffer, int len, long seed)
123 for (i = 0; i < len; i++) {
124 ch = random() & 0xff;
132 * Initialize a testing context given the file descriptors provided by the
136 aio_context_init(struct aio_context *ac, int read_fd,
137 int write_fd, int buflen)
140 ATF_REQUIRE_MSG(buflen <= BUFFER_MAX,
141 "aio_context_init: buffer too large (%d > %d)",
143 bzero(ac, sizeof(*ac));
144 ac->ac_read_fd = read_fd;
145 ac->ac_write_fd = write_fd;
146 ac->ac_buflen = buflen;
148 ac->ac_seed = random();
149 aio_fill_buffer(ac->ac_buffer, buflen, ac->ac_seed);
150 ATF_REQUIRE_MSG(aio_test_buffer(ac->ac_buffer, buflen,
151 ac->ac_seed) != 0, "aio_test_buffer: internal error");
155 poll(struct aiocb *aio)
159 while ((error = aio_error(aio)) == EINPROGRESS)
164 return (aio_return(aio));
168 sigusr1_handler(int sig __unused)
170 ATF_REQUIRE_EQ(0, sem_post(&completions));
174 thr_handler(union sigval sv __unused)
176 ATF_REQUIRE_EQ(0, sem_post(&completions));
180 poll_signaled(struct aiocb *aio)
184 ATF_REQUIRE_EQ(0, sem_wait(&completions));
185 error = aio_error(aio);
191 return (aio_return(aio));
198 * Setup a signal handler for signal delivery tests
199 * This isn't thread safe, but it's ok since ATF runs each testcase in a
202 static struct sigevent*
205 static struct sigevent sev;
207 ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
208 sev.sigev_notify = SIGEV_SIGNAL;
209 sev.sigev_signo = SIGUSR1;
210 ATF_REQUIRE(SIG_ERR != signal(SIGUSR1, sigusr1_handler));
215 * Setup a thread for thread delivery tests
216 * This isn't thread safe, but it's ok since ATF runs each testcase in a
219 static struct sigevent*
222 static struct sigevent sev;
224 ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
225 sev.sigev_notify = SIGEV_THREAD;
226 sev.sigev_notify_function = thr_handler;
227 sev.sigev_notify_attributes = NULL;
232 suspend(struct aiocb *aio)
234 const struct aiocb *const iocbs[] = {aio};
237 error = aio_suspend(iocbs, 1, NULL);
239 return (aio_return(aio));
245 waitcomplete(struct aiocb *aio)
250 ret = aio_waitcomplete(&aiop, NULL);
251 ATF_REQUIRE_EQ(aio, aiop);
256 * Setup an iocb for kqueue notification. This isn't thread
257 * safe, but it's ok because ATF runs every test case in a separate process.
259 static struct sigevent*
262 static struct sigevent sev;
266 ATF_REQUIRE(kq >= 0);
268 memset(&sev, 0, sizeof(sev));
269 sev.sigev_notify_kqueue = kq;
270 sev.sigev_value.sival_ptr = (void*)0xdeadbeef;
271 sev.sigev_notify = SIGEV_KEVENT;
277 poll_kqueue(struct aiocb *aio)
280 struct kevent events[1];
282 kq = aio->aio_sigevent.sigev_notify_kqueue;
284 nevents = kevent(kq, NULL, 0, events, 1, NULL);
285 ATF_CHECK_EQ(1, nevents);
286 ATF_CHECK_EQ(events[0].ident, (uintptr_t) aio);
287 ATF_CHECK_EQ(events[0].filter, EVFILT_AIO);
288 ATF_CHECK_EQ(events[0].flags, EV_EOF);
289 ATF_CHECK_EQ(events[0].fflags, 0);
290 ATF_CHECK_EQ(events[0].data, 0);
291 ATF_CHECK_EQ((uintptr_t)events[0].udata, 0xdeadbeef);
293 return (aio_return(aio));
297 * Perform a simple write test of our initialized data buffer to the provided
301 aio_write_test(struct aio_context *ac, completion comp, struct sigevent *sev)
306 bzero(&aio, sizeof(aio));
307 aio.aio_buf = ac->ac_buffer;
308 aio.aio_nbytes = ac->ac_buflen;
309 aio.aio_fildes = ac->ac_write_fd;
312 aio.aio_sigevent = *sev;
314 if (aio_write(&aio) < 0)
315 atf_tc_fail("aio_write failed: %s", strerror(errno));
319 atf_tc_fail("aio failed: %s", strerror(errno));
321 if (len != ac->ac_buflen)
322 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
326 * Perform a vectored I/O test of our initialized data buffer to the provided
329 * To vectorize the linear buffer, chop it up into two pieces of dissimilar
330 * size, and swap their offsets.
333 aio_writev_test(struct aio_context *ac, completion comp, struct sigevent *sev)
340 bzero(&aio, sizeof(aio));
342 aio.aio_fildes = ac->ac_write_fd;
344 len0 = ac->ac_buflen * 3 / 4;
345 len1 = ac->ac_buflen / 4;
346 iov[0].iov_base = ac->ac_buffer + len1;
347 iov[0].iov_len = len0;
348 iov[1].iov_base = ac->ac_buffer;
349 iov[1].iov_len = len1;
353 aio.aio_sigevent = *sev;
355 if (aio_writev(&aio) < 0)
356 atf_tc_fail("aio_writev failed: %s", strerror(errno));
360 atf_tc_fail("aio failed: %s", strerror(errno));
362 if (len != ac->ac_buflen)
363 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
367 * Perform a simple read test of our initialized data buffer from the
368 * provided file descriptor.
371 aio_read_test(struct aio_context *ac, completion comp, struct sigevent *sev)
376 bzero(ac->ac_buffer, ac->ac_buflen);
377 bzero(&aio, sizeof(aio));
378 aio.aio_buf = ac->ac_buffer;
379 aio.aio_nbytes = ac->ac_buflen;
380 aio.aio_fildes = ac->ac_read_fd;
383 aio.aio_sigevent = *sev;
385 if (aio_read(&aio) < 0)
386 atf_tc_fail("aio_read failed: %s", strerror(errno));
390 atf_tc_fail("aio failed: %s", strerror(errno));
392 ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
393 "aio short read (%jd)", (intmax_t)len);
395 if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
396 atf_tc_fail("buffer mismatched");
400 aio_readv_test(struct aio_context *ac, completion comp, struct sigevent *sev)
407 bzero(ac->ac_buffer, ac->ac_buflen);
408 bzero(&aio, sizeof(aio));
409 aio.aio_fildes = ac->ac_read_fd;
411 len0 = ac->ac_buflen * 3 / 4;
412 len1 = ac->ac_buflen / 4;
413 iov[0].iov_base = ac->ac_buffer + len1;
414 iov[0].iov_len = len0;
415 iov[1].iov_base = ac->ac_buffer;
416 iov[1].iov_len = len1;
420 aio.aio_sigevent = *sev;
422 if (aio_readv(&aio) < 0)
423 atf_tc_fail("aio_read failed: %s", strerror(errno));
427 atf_tc_fail("aio failed: %s", strerror(errno));
429 ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
430 "aio short read (%jd)", (intmax_t)len);
432 if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
433 atf_tc_fail("buffer mismatched");
437 * Series of type-specific tests for AIO. For now, we just make sure we can
438 * issue a write and then a read to each type. We assume that once a write
439 * is issued, a read can follow.
443 * Test with a classic file. Assumes we can create a moderate size temporary
446 #define FILE_LEN GLOBAL_MAX
447 #define FILE_PATHNAME "testfile"
450 aio_file_test(completion comp, struct sigevent *sev, bool vectored)
452 struct aio_context ac;
455 ATF_REQUIRE_KERNEL_MODULE("aio");
456 ATF_REQUIRE_UNSAFE_AIO();
458 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
459 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
461 aio_context_init(&ac, fd, fd, FILE_LEN);
463 aio_writev_test(&ac, comp, sev);
464 aio_readv_test(&ac, comp, sev);
466 aio_write_test(&ac, comp, sev);
467 aio_read_test(&ac, comp, sev);
472 ATF_TC_WITHOUT_HEAD(file_kq);
473 ATF_TC_BODY(file_kq, tc)
475 aio_file_test(poll_kqueue, setup_kqueue(), false);
478 ATF_TC_WITHOUT_HEAD(file_poll);
479 ATF_TC_BODY(file_poll, tc)
481 aio_file_test(poll, NULL, false);
484 ATF_TC_WITHOUT_HEAD(file_signal);
485 ATF_TC_BODY(file_signal, tc)
487 aio_file_test(poll_signaled, setup_signal(), false);
490 ATF_TC_WITHOUT_HEAD(file_suspend);
491 ATF_TC_BODY(file_suspend, tc)
493 aio_file_test(suspend, NULL, false);
496 ATF_TC_WITHOUT_HEAD(file_thread);
497 ATF_TC_BODY(file_thread, tc)
499 aio_file_test(poll_signaled, setup_thread(), false);
502 ATF_TC_WITHOUT_HEAD(file_waitcomplete);
503 ATF_TC_BODY(file_waitcomplete, tc)
505 aio_file_test(waitcomplete, NULL, false);
509 #define FIFO_PATHNAME "testfifo"
512 aio_fifo_test(completion comp, struct sigevent *sev)
514 int error, read_fd = -1, write_fd = -1;
515 struct aio_context ac;
517 ATF_REQUIRE_KERNEL_MODULE("aio");
518 ATF_REQUIRE_UNSAFE_AIO();
520 ATF_REQUIRE_MSG(mkfifo(FIFO_PATHNAME, 0600) != -1,
521 "mkfifo failed: %s", strerror(errno));
523 read_fd = open(FIFO_PATHNAME, O_RDONLY | O_NONBLOCK);
527 atf_tc_fail("read_fd open failed: %s",
531 write_fd = open(FIFO_PATHNAME, O_WRONLY);
532 if (write_fd == -1) {
535 atf_tc_fail("write_fd open failed: %s",
539 aio_context_init(&ac, read_fd, write_fd, FIFO_LEN);
540 aio_write_test(&ac, comp, sev);
541 aio_read_test(&ac, comp, sev);
547 ATF_TC_WITHOUT_HEAD(fifo_kq);
548 ATF_TC_BODY(fifo_kq, tc)
550 aio_fifo_test(poll_kqueue, setup_kqueue());
553 ATF_TC_WITHOUT_HEAD(fifo_poll);
554 ATF_TC_BODY(fifo_poll, tc)
556 aio_fifo_test(poll, NULL);
559 ATF_TC_WITHOUT_HEAD(fifo_signal);
560 ATF_TC_BODY(fifo_signal, tc)
562 aio_fifo_test(poll_signaled, setup_signal());
565 ATF_TC_WITHOUT_HEAD(fifo_suspend);
566 ATF_TC_BODY(fifo_suspend, tc)
568 aio_fifo_test(suspend, NULL);
571 ATF_TC_WITHOUT_HEAD(fifo_thread);
572 ATF_TC_BODY(fifo_thread, tc)
574 aio_fifo_test(poll_signaled, setup_thread());
577 ATF_TC_WITHOUT_HEAD(fifo_waitcomplete);
578 ATF_TC_BODY(fifo_waitcomplete, tc)
580 aio_fifo_test(waitcomplete, NULL);
583 #define UNIX_SOCKETPAIR_LEN 256
585 aio_unix_socketpair_test(completion comp, struct sigevent *sev, bool vectored)
587 struct aio_context ac;
588 struct rusage ru_before, ru_after;
591 ATF_REQUIRE_KERNEL_MODULE("aio");
593 ATF_REQUIRE_MSG(socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) != -1,
594 "socketpair failed: %s", strerror(errno));
596 aio_context_init(&ac, sockets[0], sockets[1], UNIX_SOCKETPAIR_LEN);
597 ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_before) != -1,
598 "getrusage failed: %s", strerror(errno));
600 aio_writev_test(&ac, comp, sev);
601 aio_readv_test(&ac, comp, sev);
603 aio_write_test(&ac, comp, sev);
604 aio_read_test(&ac, comp, sev);
606 ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_after) != -1,
607 "getrusage failed: %s", strerror(errno));
608 ATF_REQUIRE(ru_after.ru_msgsnd == ru_before.ru_msgsnd + 1);
609 ATF_REQUIRE(ru_after.ru_msgrcv == ru_before.ru_msgrcv + 1);
615 ATF_TC_WITHOUT_HEAD(socket_kq);
616 ATF_TC_BODY(socket_kq, tc)
618 aio_unix_socketpair_test(poll_kqueue, setup_kqueue(), false);
621 ATF_TC_WITHOUT_HEAD(socket_poll);
622 ATF_TC_BODY(socket_poll, tc)
624 aio_unix_socketpair_test(poll, NULL, false);
627 ATF_TC_WITHOUT_HEAD(socket_signal);
628 ATF_TC_BODY(socket_signal, tc)
630 aio_unix_socketpair_test(poll_signaled, setup_signal(), false);
633 ATF_TC_WITHOUT_HEAD(socket_suspend);
634 ATF_TC_BODY(socket_suspend, tc)
636 aio_unix_socketpair_test(suspend, NULL, false);
639 ATF_TC_WITHOUT_HEAD(socket_thread);
640 ATF_TC_BODY(socket_thread, tc)
642 aio_unix_socketpair_test(poll_signaled, setup_thread(), false);
645 ATF_TC_WITHOUT_HEAD(socket_waitcomplete);
646 ATF_TC_BODY(socket_waitcomplete, tc)
648 aio_unix_socketpair_test(waitcomplete, NULL, false);
658 aio_pty_test(completion comp, struct sigevent *sev)
660 struct aio_context ac;
661 int read_fd, write_fd;
665 ATF_REQUIRE_KERNEL_MODULE("aio");
666 ATF_REQUIRE_UNSAFE_AIO();
668 ATF_REQUIRE_MSG(openpty(&read_fd, &write_fd, NULL, NULL, NULL) == 0,
669 "openpty failed: %s", strerror(errno));
672 if (tcgetattr(write_fd, &ts) < 0) {
675 atf_tc_fail("tcgetattr failed: %s", strerror(errno));
678 if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
681 atf_tc_fail("tcsetattr failed: %s", strerror(errno));
683 aio_context_init(&ac, read_fd, write_fd, PTY_LEN);
685 aio_write_test(&ac, comp, sev);
686 aio_read_test(&ac, comp, sev);
692 ATF_TC_WITHOUT_HEAD(pty_kq);
693 ATF_TC_BODY(pty_kq, tc)
695 aio_pty_test(poll_kqueue, setup_kqueue());
698 ATF_TC_WITHOUT_HEAD(pty_poll);
699 ATF_TC_BODY(pty_poll, tc)
701 aio_pty_test(poll, NULL);
704 ATF_TC_WITHOUT_HEAD(pty_signal);
705 ATF_TC_BODY(pty_signal, tc)
707 aio_pty_test(poll_signaled, setup_signal());
710 ATF_TC_WITHOUT_HEAD(pty_suspend);
711 ATF_TC_BODY(pty_suspend, tc)
713 aio_pty_test(suspend, NULL);
716 ATF_TC_WITHOUT_HEAD(pty_thread);
717 ATF_TC_BODY(pty_thread, tc)
719 aio_pty_test(poll_signaled, setup_thread());
722 ATF_TC_WITHOUT_HEAD(pty_waitcomplete);
723 ATF_TC_BODY(pty_waitcomplete, tc)
725 aio_pty_test(waitcomplete, NULL);
730 aio_pipe_test(completion comp, struct sigevent *sev)
732 struct aio_context ac;
735 ATF_REQUIRE_KERNEL_MODULE("aio");
736 ATF_REQUIRE_UNSAFE_AIO();
738 ATF_REQUIRE_MSG(pipe(pipes) != -1,
739 "pipe failed: %s", strerror(errno));
741 aio_context_init(&ac, pipes[0], pipes[1], PIPE_LEN);
742 aio_write_test(&ac, comp, sev);
743 aio_read_test(&ac, comp, sev);
749 ATF_TC_WITHOUT_HEAD(pipe_kq);
750 ATF_TC_BODY(pipe_kq, tc)
752 aio_pipe_test(poll_kqueue, setup_kqueue());
755 ATF_TC_WITHOUT_HEAD(pipe_poll);
756 ATF_TC_BODY(pipe_poll, tc)
758 aio_pipe_test(poll, NULL);
761 ATF_TC_WITHOUT_HEAD(pipe_signal);
762 ATF_TC_BODY(pipe_signal, tc)
764 aio_pipe_test(poll_signaled, setup_signal());
767 ATF_TC_WITHOUT_HEAD(pipe_suspend);
768 ATF_TC_BODY(pipe_suspend, tc)
770 aio_pipe_test(suspend, NULL);
773 ATF_TC_WITHOUT_HEAD(pipe_thread);
774 ATF_TC_BODY(pipe_thread, tc)
776 aio_pipe_test(poll_signaled, setup_thread());
779 ATF_TC_WITHOUT_HEAD(pipe_waitcomplete);
780 ATF_TC_BODY(pipe_waitcomplete, tc)
782 aio_pipe_test(waitcomplete, NULL);
785 #define MD_LEN GLOBAL_MAX
786 #define MDUNIT_LINK "mdunit_link"
791 int error, fd, mdctl_fd, unit;
792 char pathname[PATH_MAX];
793 struct md_ioctl mdio;
796 ATF_REQUIRE_KERNEL_MODULE("aio");
798 mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
799 ATF_REQUIRE_MSG(mdctl_fd != -1,
800 "opening /dev/%s failed: %s", MDCTL_NAME, strerror(errno));
802 bzero(&mdio, sizeof(mdio));
803 mdio.md_version = MDIOVERSION;
804 mdio.md_type = MD_MALLOC;
805 mdio.md_options = MD_AUTOUNIT | MD_COMPRESS;
806 mdio.md_mediasize = GLOBAL_MAX;
807 mdio.md_sectorsize = 512;
808 strlcpy(buf, __func__, sizeof(buf));
811 if (ioctl(mdctl_fd, MDIOCATTACH, &mdio) < 0) {
814 atf_tc_fail("ioctl MDIOCATTACH failed: %s", strerror(errno));
818 /* Store the md unit number in a symlink for future cleanup */
820 snprintf(buf, sizeof(buf), "%d", unit);
821 ATF_REQUIRE_EQ(0, symlink(buf, MDUNIT_LINK));
822 snprintf(pathname, PATH_MAX, "/dev/md%d", unit);
823 fd = open(pathname, O_RDWR);
824 ATF_REQUIRE_MSG(fd != -1,
825 "opening %s failed: %s", pathname, strerror(errno));
833 struct md_ioctl mdio;
834 int mdctl_fd, n, unit;
837 mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
839 fprintf(stderr, "opening /dev/%s failed: %s\n", MDCTL_NAME,
843 n = readlink(MDUNIT_LINK, buf, sizeof(buf) - 1);
846 if (sscanf(buf, "%d", &unit) == 1 && unit >= 0) {
847 bzero(&mdio, sizeof(mdio));
848 mdio.md_version = MDIOVERSION;
850 if (ioctl(mdctl_fd, MDIOCDETACH, &mdio) == -1) {
852 "ioctl MDIOCDETACH unit %d failed: %s\n",
853 unit, strerror(errno));
862 aio_md_test(completion comp, struct sigevent *sev, bool vectored)
864 struct aio_context ac;
868 aio_context_init(&ac, fd, fd, MD_LEN);
870 aio_writev_test(&ac, comp, sev);
871 aio_readv_test(&ac, comp, sev);
873 aio_write_test(&ac, comp, sev);
874 aio_read_test(&ac, comp, sev);
880 ATF_TC_WITH_CLEANUP(md_kq);
881 ATF_TC_HEAD(md_kq, tc)
884 atf_tc_set_md_var(tc, "require.user", "root");
886 ATF_TC_BODY(md_kq, tc)
888 aio_md_test(poll_kqueue, setup_kqueue(), false);
890 ATF_TC_CLEANUP(md_kq, tc)
895 ATF_TC_WITH_CLEANUP(md_poll);
896 ATF_TC_HEAD(md_poll, tc)
899 atf_tc_set_md_var(tc, "require.user", "root");
901 ATF_TC_BODY(md_poll, tc)
903 aio_md_test(poll, NULL, false);
905 ATF_TC_CLEANUP(md_poll, tc)
910 ATF_TC_WITH_CLEANUP(md_signal);
911 ATF_TC_HEAD(md_signal, tc)
914 atf_tc_set_md_var(tc, "require.user", "root");
916 ATF_TC_BODY(md_signal, tc)
918 aio_md_test(poll_signaled, setup_signal(), false);
920 ATF_TC_CLEANUP(md_signal, tc)
925 ATF_TC_WITH_CLEANUP(md_suspend);
926 ATF_TC_HEAD(md_suspend, tc)
929 atf_tc_set_md_var(tc, "require.user", "root");
931 ATF_TC_BODY(md_suspend, tc)
933 aio_md_test(suspend, NULL, false);
935 ATF_TC_CLEANUP(md_suspend, tc)
940 ATF_TC_WITH_CLEANUP(md_thread);
941 ATF_TC_HEAD(md_thread, tc)
944 atf_tc_set_md_var(tc, "require.user", "root");
946 ATF_TC_BODY(md_thread, tc)
948 aio_md_test(poll_signaled, setup_thread(), false);
950 ATF_TC_CLEANUP(md_thread, tc)
955 ATF_TC_WITH_CLEANUP(md_waitcomplete);
956 ATF_TC_HEAD(md_waitcomplete, tc)
959 atf_tc_set_md_var(tc, "require.user", "root");
961 ATF_TC_BODY(md_waitcomplete, tc)
963 aio_md_test(waitcomplete, NULL, false);
965 ATF_TC_CLEANUP(md_waitcomplete, tc)
970 #define ZVOL_VDEV_PATHNAME "test_vdev"
971 #define POOL_SIZE (1 << 28) /* 256 MB */
972 #define ZVOL_SIZE "64m"
973 #define POOL_NAME "aio_testpool"
974 #define ZVOL_NAME "aio_testvol"
977 aio_zvol_setup(const char *unique)
988 ATF_REQUIRE_KERNEL_MODULE("aio");
989 ATF_REQUIRE_KERNEL_MODULE("zfs");
992 snprintf(vdev_name, sizeof(vdev_name), "%s", ZVOL_VDEV_PATHNAME);
993 snprintf(pool_name, sizeof(pool_name), "%s_%s.%d", POOL_NAME, unique,
995 snprintf(zvol_name, sizeof(zvol_name), "%s/%s_%s", pool_name, ZVOL_NAME,
998 fd = open(vdev_name, O_RDWR | O_CREAT, 0600);
999 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1000 ATF_REQUIRE_EQ_MSG(0,
1001 ftruncate(fd, POOL_SIZE), "ftruncate failed: %s", strerror(errno));
1004 pidfile = fopen("pidfile", "w");
1005 ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
1006 fprintf(pidfile, "%d", pid);
1009 snprintf(cmd, sizeof(cmd), "zpool create %s $PWD/%s", pool_name,
1011 ATF_REQUIRE_EQ_MSG(0, system(cmd),
1012 "zpool create failed: %s", strerror(errno));
1013 snprintf(cmd, sizeof(cmd),
1014 "zfs create -o volblocksize=8192 -o volmode=dev -V %s %s",
1015 ZVOL_SIZE, zvol_name);
1016 ATF_REQUIRE_EQ_MSG(0, system(cmd),
1017 "zfs create failed: %s", strerror(errno));
1019 snprintf(devname, sizeof(devname), "/dev/zvol/%s", zvol_name);
1021 fd = open(devname, O_RDWR);
1022 } while (fd == -1 && errno == EINTR);
1023 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1028 aio_zvol_cleanup(const char *unique)
1034 pidfile = fopen("pidfile", "r");
1035 if (pidfile == NULL && errno == ENOENT) {
1036 /* Setup probably failed */
1039 ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
1040 ATF_REQUIRE_EQ(1, fscanf(pidfile, "%d", &testpid));
1043 snprintf(cmd, sizeof(cmd), "zpool destroy %s_%s.%d", POOL_NAME, unique,
1049 ATF_TC_WITHOUT_HEAD(aio_large_read_test);
1050 ATF_TC_BODY(aio_large_read_test, tc)
1052 struct aiocb cb, *cbp;
1060 ATF_REQUIRE_KERNEL_MODULE("aio");
1061 ATF_REQUIRE_UNSAFE_AIO();
1064 len = sizeof(clamped);
1065 if (sysctlbyname("debug.iosize_max_clamp", &clamped, &len, NULL, 0) ==
1067 atf_libc_error(errno, "Failed to read debug.iosize_max_clamp");
1070 /* Determine the maximum supported read(2) size. */
1077 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1078 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1080 unlink(FILE_PATHNAME);
1082 memset(&cb, 0, sizeof(cb));
1083 cb.aio_nbytes = len;
1086 if (aio_read(&cb) == -1)
1087 atf_tc_fail("aio_read() of maximum read size failed: %s",
1090 nread = aio_waitcomplete(&cbp, NULL);
1092 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1094 atf_tc_fail("aio_read() from empty file returned data: %zd",
1097 memset(&cb, 0, sizeof(cb));
1098 cb.aio_nbytes = len + 1;
1101 if (aio_read(&cb) == -1) {
1102 if (errno == EINVAL)
1104 atf_tc_fail("aio_read() of too large read size failed: %s",
1108 nread = aio_waitcomplete(&cbp, NULL);
1110 if (errno == EINVAL)
1112 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1114 atf_tc_fail("aio_read() of too large read size returned: %zd", nread);
1121 * This tests for a bug where arriving socket data can wakeup multiple
1122 * AIO read requests resulting in an uncancellable request.
1124 ATF_TC_WITHOUT_HEAD(aio_socket_two_reads);
1125 ATF_TC_BODY(aio_socket_two_reads, tc)
1136 ATF_REQUIRE_KERNEL_MODULE("aio");
1137 #if __FreeBSD_version < 1100101
1138 aft_tc_skip("kernel version %d is too old (%d required)",
1139 __FreeBSD_version, 1100101);
1142 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1144 /* Queue two read requests. */
1145 memset(&ioreq, 0, sizeof(ioreq));
1146 for (i = 0; i < nitems(ioreq); i++) {
1147 ioreq[i].iocb.aio_nbytes = sizeof(ioreq[i].buffer);
1148 ioreq[i].iocb.aio_fildes = s[0];
1149 ioreq[i].iocb.aio_buf = ioreq[i].buffer;
1150 ATF_REQUIRE(aio_read(&ioreq[i].iocb) == 0);
1153 /* Send a single byte. This should complete one request. */
1155 ATF_REQUIRE(write(s[1], &c, sizeof(c)) == 1);
1157 ATF_REQUIRE(aio_waitcomplete(&iocb, NULL) == 1);
1159 /* Determine which request completed and verify the data was read. */
1160 if (iocb == &ioreq[0].iocb)
1164 ATF_REQUIRE(ioreq[i].buffer[0] == c);
1169 * Try to cancel the other request. On broken systems this
1170 * will fail and the process will hang on exit.
1172 ATF_REQUIRE(aio_error(&ioreq[i].iocb) == EINPROGRESS);
1173 ATF_REQUIRE(aio_cancel(s[0], &ioreq[i].iocb) == AIO_CANCELED);
1180 aio_socket_blocking_short_write_test(bool vectored)
1182 struct aiocb iocb, *iocbp;
1183 struct iovec iov[2];
1186 int buffer_size, sb_size;
1190 ATF_REQUIRE_KERNEL_MODULE("aio");
1192 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1194 len = sizeof(sb_size);
1195 ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1197 ATF_REQUIRE(len == sizeof(sb_size));
1198 buffer_size = sb_size;
1200 ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1202 ATF_REQUIRE(len == sizeof(sb_size));
1203 if (sb_size > buffer_size)
1204 buffer_size = sb_size;
1207 * Use twice the size of the MAX(receive buffer, send buffer)
1208 * to ensure that the write is split up into multiple writes
1213 buffer[0] = malloc(buffer_size);
1214 ATF_REQUIRE(buffer[0] != NULL);
1215 buffer[1] = malloc(buffer_size);
1216 ATF_REQUIRE(buffer[1] != NULL);
1219 aio_fill_buffer(buffer[1], buffer_size, random());
1221 memset(&iocb, 0, sizeof(iocb));
1222 iocb.aio_fildes = s[1];
1224 iov[0].iov_base = buffer[1];
1225 iov[0].iov_len = buffer_size / 2 + 1;
1226 iov[1].iov_base = buffer[1] + buffer_size / 2 + 1;
1227 iov[1].iov_len = buffer_size / 2 - 1;
1229 iocb.aio_iovcnt = 2;
1230 r = aio_writev(&iocb);
1231 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1233 iocb.aio_buf = buffer[1];
1234 iocb.aio_nbytes = buffer_size;
1235 r = aio_write(&iocb);
1236 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1239 done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1240 ATF_REQUIRE(done == buffer_size);
1242 done = aio_waitcomplete(&iocbp, NULL);
1243 ATF_REQUIRE(iocbp == &iocb);
1244 ATF_REQUIRE(done == buffer_size);
1246 ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1253 * This test ensures that aio_write() on a blocking socket of a "large"
1254 * buffer does not return a short completion.
1256 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write);
1257 ATF_TC_BODY(aio_socket_blocking_short_write, tc)
1259 aio_socket_blocking_short_write_test(false);
1263 * Like aio_socket_blocking_short_write, but also tests that partially
1264 * completed vectored sends can be retried correctly.
1266 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write_vectored);
1267 ATF_TC_BODY(aio_socket_blocking_short_write_vectored, tc)
1269 aio_socket_blocking_short_write_test(true);
1273 * Verify that AIO requests fail when applied to a listening socket.
1275 ATF_TC_WITHOUT_HEAD(aio_socket_listen_fail);
1276 ATF_TC_BODY(aio_socket_listen_fail, tc)
1279 struct sockaddr_un sun;
1283 s = socket(AF_LOCAL, SOCK_STREAM, 0);
1284 ATF_REQUIRE(s != -1);
1286 memset(&sun, 0, sizeof(sun));
1287 snprintf(sun.sun_path, sizeof(sun.sun_path), "%s", "listen.XXXXXX");
1288 mktemp(sun.sun_path);
1289 sun.sun_family = AF_LOCAL;
1290 sun.sun_len = SUN_LEN(&sun);
1292 ATF_REQUIRE(bind(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) == 0);
1293 ATF_REQUIRE(listen(s, 5) == 0);
1295 memset(buf, 0, sizeof(buf));
1296 memset(&iocb, 0, sizeof(iocb));
1297 iocb.aio_fildes = s;
1299 iocb.aio_nbytes = sizeof(buf);
1301 ATF_REQUIRE_ERRNO(EINVAL, aio_read(&iocb) == -1);
1302 ATF_REQUIRE_ERRNO(EINVAL, aio_write(&iocb) == -1);
1304 ATF_REQUIRE(unlink(sun.sun_path) == 0);
1309 * Verify that listen(2) fails if a socket has pending AIO requests.
1311 ATF_TC_WITHOUT_HEAD(aio_socket_listen_pending);
1312 ATF_TC_BODY(aio_socket_listen_pending, tc)
1315 struct sockaddr_un sun;
1319 s = socket(AF_LOCAL, SOCK_STREAM, 0);
1320 ATF_REQUIRE(s != -1);
1322 memset(&sun, 0, sizeof(sun));
1323 snprintf(sun.sun_path, sizeof(sun.sun_path), "%s", "listen.XXXXXX");
1324 mktemp(sun.sun_path);
1325 sun.sun_family = AF_LOCAL;
1326 sun.sun_len = SUN_LEN(&sun);
1328 ATF_REQUIRE(bind(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) == 0);
1330 memset(buf, 0, sizeof(buf));
1331 memset(&iocb, 0, sizeof(iocb));
1332 iocb.aio_fildes = s;
1334 iocb.aio_nbytes = sizeof(buf);
1335 ATF_REQUIRE(aio_read(&iocb) == 0);
1337 ATF_REQUIRE_ERRNO(EINVAL, listen(s, 5) == -1);
1339 ATF_REQUIRE(aio_cancel(s, &iocb) != -1);
1341 ATF_REQUIRE(unlink(sun.sun_path) == 0);
1346 * This test verifies that cancelling a partially completed socket write
1347 * returns a short write rather than ECANCELED.
1349 ATF_TC_WITHOUT_HEAD(aio_socket_short_write_cancel);
1350 ATF_TC_BODY(aio_socket_short_write_cancel, tc)
1352 struct aiocb iocb, *iocbp;
1355 int buffer_size, sb_size;
1359 ATF_REQUIRE_KERNEL_MODULE("aio");
1361 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1363 len = sizeof(sb_size);
1364 ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1366 ATF_REQUIRE(len == sizeof(sb_size));
1367 buffer_size = sb_size;
1369 ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1371 ATF_REQUIRE(len == sizeof(sb_size));
1372 if (sb_size > buffer_size)
1373 buffer_size = sb_size;
1376 * Use three times the size of the MAX(receive buffer, send
1377 * buffer) for the write to ensure that the write is split up
1378 * into multiple writes internally. The recv() ensures that
1379 * the write has partially completed, but a remaining size of
1380 * two buffers should ensure that the write has not completed
1381 * fully when it is cancelled.
1383 buffer[0] = malloc(buffer_size);
1384 ATF_REQUIRE(buffer[0] != NULL);
1385 buffer[1] = malloc(buffer_size * 3);
1386 ATF_REQUIRE(buffer[1] != NULL);
1389 aio_fill_buffer(buffer[1], buffer_size * 3, random());
1391 memset(&iocb, 0, sizeof(iocb));
1392 iocb.aio_fildes = s[1];
1393 iocb.aio_buf = buffer[1];
1394 iocb.aio_nbytes = buffer_size * 3;
1395 ATF_REQUIRE(aio_write(&iocb) == 0);
1397 done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1398 ATF_REQUIRE(done == buffer_size);
1400 ATF_REQUIRE(aio_error(&iocb) == EINPROGRESS);
1401 ATF_REQUIRE(aio_cancel(s[1], &iocb) == AIO_NOTCANCELED);
1403 done = aio_waitcomplete(&iocbp, NULL);
1404 ATF_REQUIRE(iocbp == &iocb);
1405 ATF_REQUIRE(done >= buffer_size && done <= buffer_size * 2);
1407 ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1414 * Test handling of aio_read() and aio_write() on shut-down sockets.
1416 ATF_TC_WITHOUT_HEAD(aio_socket_shutdown);
1417 ATF_TC_BODY(aio_socket_shutdown, tc)
1426 ATF_REQUIRE_KERNEL_MODULE("aio");
1428 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1431 buffer = malloc(bsz);
1432 memset(buffer, 0, bsz);
1434 /* Put some data in s[0]'s recv buffer. */
1435 ATF_REQUIRE(send(s[1], buffer, bsz, 0) == (ssize_t)bsz);
1437 /* No more reading from s[0]. */
1438 ATF_REQUIRE(shutdown(s[0], SHUT_RD) != -1);
1440 ATF_REQUIRE(buffer != NULL);
1442 memset(&iocb, 0, sizeof(iocb));
1443 iocb.aio_fildes = s[0];
1444 iocb.aio_buf = buffer;
1445 iocb.aio_nbytes = bsz;
1446 ATF_REQUIRE(aio_read(&iocb) == 0);
1448 /* Expect to see zero bytes, analogous to recv(2). */
1449 while ((error = aio_error(&iocb)) == EINPROGRESS)
1451 ATF_REQUIRE_MSG(error == 0, "aio_error() returned %d", error);
1452 len = aio_return(&iocb);
1453 ATF_REQUIRE_MSG(len == 0, "read job returned %zd bytes", len);
1455 /* No more writing to s[1]. */
1456 ATF_REQUIRE(shutdown(s[1], SHUT_WR) != -1);
1458 /* Block SIGPIPE so that we can detect the error in-band. */
1460 sigaddset(&set, SIGPIPE);
1461 ATF_REQUIRE(sigprocmask(SIG_BLOCK, &set, NULL) == 0);
1463 memset(&iocb, 0, sizeof(iocb));
1464 iocb.aio_fildes = s[1];
1465 iocb.aio_buf = buffer;
1466 iocb.aio_nbytes = bsz;
1467 ATF_REQUIRE(aio_write(&iocb) == 0);
1469 /* Expect an error, analogous to send(2). */
1470 while ((error = aio_error(&iocb)) == EINPROGRESS)
1472 ATF_REQUIRE_MSG(error == EPIPE, "aio_error() returned %d", error);
1474 ATF_REQUIRE(close(s[0]) != -1);
1475 ATF_REQUIRE(close(s[1]) != -1);
1480 * test aio_fsync's behavior with bad inputs
1482 ATF_TC_WITHOUT_HEAD(aio_fsync_errors);
1483 ATF_TC_BODY(aio_fsync_errors, tc)
1488 ATF_REQUIRE_KERNEL_MODULE("aio");
1489 ATF_REQUIRE_UNSAFE_AIO();
1491 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1492 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1493 unlink(FILE_PATHNAME);
1495 /* aio_fsync should return EINVAL unless op is O_SYNC or O_DSYNC */
1496 memset(&iocb, 0, sizeof(iocb));
1497 iocb.aio_fildes = fd;
1498 ATF_CHECK_EQ(-1, aio_fsync(666, &iocb));
1499 ATF_CHECK_EQ(EINVAL, errno);
1501 /* aio_fsync should return EBADF if fd is not a valid descriptor */
1502 memset(&iocb, 0, sizeof(iocb));
1503 iocb.aio_fildes = 666;
1504 ATF_CHECK_EQ(-1, aio_fsync(O_SYNC, &iocb));
1505 ATF_CHECK_EQ(EBADF, errno);
1507 /* aio_fsync should return EINVAL if sigev_notify is invalid */
1508 memset(&iocb, 0, sizeof(iocb));
1509 iocb.aio_fildes = fd;
1510 iocb.aio_sigevent.sigev_notify = 666;
1511 ATF_CHECK_EQ(-1, aio_fsync(666, &iocb));
1512 ATF_CHECK_EQ(EINVAL, errno);
1516 * This test just performs a basic test of aio_fsync().
1519 aio_fsync_test(int op)
1521 struct aiocb synccb, *iocbp;
1532 ATF_REQUIRE_KERNEL_MODULE("aio");
1533 ATF_REQUIRE_UNSAFE_AIO();
1535 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1536 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1537 unlink(FILE_PATHNAME);
1539 ATF_REQUIRE(fstat(fd, &sb) == 0);
1540 ATF_REQUIRE(sb.st_blksize != 0);
1541 ATF_REQUIRE(ftruncate(fd, sb.st_blksize * nitems(buffers)) == 0);
1544 * Queue several asynchronous write requests. Hopefully this
1545 * forces the aio_fsync() request to be deferred. There is no
1546 * reliable way to guarantee that however.
1549 for (i = 0; i < nitems(buffers); i++) {
1550 buffers[i].done = false;
1551 memset(&buffers[i].iocb, 0, sizeof(buffers[i].iocb));
1552 buffers[i].buffer = malloc(sb.st_blksize);
1553 aio_fill_buffer(buffers[i].buffer, sb.st_blksize, random());
1554 buffers[i].iocb.aio_fildes = fd;
1555 buffers[i].iocb.aio_buf = buffers[i].buffer;
1556 buffers[i].iocb.aio_nbytes = sb.st_blksize;
1557 buffers[i].iocb.aio_offset = sb.st_blksize * i;
1558 ATF_REQUIRE(aio_write(&buffers[i].iocb) == 0);
1561 /* Queue the aio_fsync request. */
1562 memset(&synccb, 0, sizeof(synccb));
1563 synccb.aio_fildes = fd;
1564 ATF_REQUIRE(aio_fsync(op, &synccb) == 0);
1566 /* Wait for requests to complete. */
1569 rval = aio_waitcomplete(&iocbp, NULL);
1570 ATF_REQUIRE(iocbp != NULL);
1571 if (iocbp == &synccb) {
1572 ATF_REQUIRE(rval == 0);
1576 for (i = 0; i < nitems(buffers); i++) {
1577 if (iocbp == &buffers[i].iocb) {
1578 ATF_REQUIRE(buffers[i].done == false);
1579 ATF_REQUIRE(rval == sb.st_blksize);
1580 buffers[i].done = true;
1585 ATF_REQUIRE_MSG(false, "unmatched AIO request");
1588 for (i = 0; i < nitems(buffers); i++)
1589 ATF_REQUIRE_MSG(buffers[i].done,
1590 "AIO request %u did not complete", i);
1595 ATF_TC_WITHOUT_HEAD(aio_fsync_sync_test);
1596 ATF_TC_BODY(aio_fsync_sync_test, tc)
1598 aio_fsync_test(O_SYNC);
1601 ATF_TC_WITHOUT_HEAD(aio_fsync_dsync_test);
1602 ATF_TC_BODY(aio_fsync_dsync_test, tc)
1604 aio_fsync_test(O_DSYNC);
1608 * We shouldn't be able to DoS the system by setting iov_len to an insane
1611 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iov_len);
1612 ATF_TC_BODY(aio_writev_dos_iov_len, tc)
1615 const struct aiocb *const iocbs[] = {&aio};
1616 const char *wbuf = "Hello, world!";
1617 struct iovec iov[1];
1621 ATF_REQUIRE_KERNEL_MODULE("aio");
1622 ATF_REQUIRE_UNSAFE_AIO();
1624 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1625 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1627 iov[0].iov_base = __DECONST(void*, wbuf);
1628 iov[0].iov_len = 1 << 30;
1629 bzero(&aio, sizeof(aio));
1630 aio.aio_fildes = fd;
1635 r = aio_writev(&aio);
1636 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1637 ATF_REQUIRE_EQ(0, aio_suspend(iocbs, 1, NULL));
1638 r = aio_return(&aio);
1639 ATF_CHECK_EQ_MSG(-1, r, "aio_return returned %zd", r);
1640 ATF_CHECK_MSG(errno == EFAULT || errno == EINVAL,
1641 "aio_writev: %s", strerror(errno));
1647 * We shouldn't be able to DoS the system by setting aio_iovcnt to an insane
1650 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iovcnt);
1651 ATF_TC_BODY(aio_writev_dos_iovcnt, tc)
1654 const char *wbuf = "Hello, world!";
1655 struct iovec iov[1];
1659 ATF_REQUIRE_KERNEL_MODULE("aio");
1660 ATF_REQUIRE_UNSAFE_AIO();
1662 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1663 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1666 iov[0].iov_base = __DECONST(void*, wbuf);
1667 iov[0].iov_len = len;
1668 bzero(&aio, sizeof(aio));
1669 aio.aio_fildes = fd;
1672 aio.aio_iovcnt = 1 << 30;
1674 ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1675 ATF_CHECK_EQ(EINVAL, errno);
1680 ATF_TC_WITH_CLEANUP(aio_writev_efault);
1681 ATF_TC_HEAD(aio_writev_efault, tc)
1683 atf_tc_set_md_var(tc, "descr",
1684 "Vectored AIO should gracefully handle invalid addresses");
1685 atf_tc_set_md_var(tc, "require.user", "root");
1687 ATF_TC_BODY(aio_writev_efault, tc)
1692 struct iovec iov[2];
1696 ATF_REQUIRE_KERNEL_MODULE("aio");
1697 ATF_REQUIRE_UNSAFE_AIO();
1699 fd = aio_md_setup();
1703 buffer = malloc(buflen);
1704 aio_fill_buffer(buffer, buflen, seed);
1705 iov[0].iov_base = buffer;
1706 iov[0].iov_len = buflen;
1707 iov[1].iov_base = (void*)-1; /* Invalid! */
1708 iov[1].iov_len = buflen;
1709 bzero(&aio, sizeof(aio));
1710 aio.aio_fildes = fd;
1713 aio.aio_iovcnt = nitems(iov);
1715 ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1716 ATF_CHECK_EQ(EFAULT, errno);
1720 ATF_TC_CLEANUP(aio_writev_efault, tc)
1725 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_poll);
1726 ATF_TC_BODY(aio_writev_empty_file_poll, tc)
1731 ATF_REQUIRE_KERNEL_MODULE("aio");
1732 ATF_REQUIRE_UNSAFE_AIO();
1734 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1735 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1737 bzero(&aio, sizeof(aio));
1738 aio.aio_fildes = fd;
1742 ATF_REQUIRE_EQ(0, aio_writev(&aio));
1743 ATF_REQUIRE_EQ(0, suspend(&aio));
1748 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_signal);
1749 ATF_TC_BODY(aio_writev_empty_file_signal, tc)
1754 ATF_REQUIRE_KERNEL_MODULE("aio");
1755 ATF_REQUIRE_UNSAFE_AIO();
1757 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1758 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1760 bzero(&aio, sizeof(aio));
1761 aio.aio_fildes = fd;
1764 aio.aio_sigevent = *setup_signal();
1766 ATF_REQUIRE_EQ(0, aio_writev(&aio));
1767 ATF_REQUIRE_EQ(0, poll_signaled(&aio));
1773 * Use an aiocb with kqueue and EV_ONESHOT. kqueue should deliver the event
1774 * only once, even if the user doesn't promptly call aio_return.
1776 ATF_TC_WITHOUT_HEAD(ev_oneshot);
1777 ATF_TC_BODY(ev_oneshot, tc)
1779 int fd, kq, nevents;
1781 struct kevent events[1];
1782 struct timespec timeout;
1784 ATF_REQUIRE_KERNEL_MODULE("aio");
1787 ATF_REQUIRE(kq >= 0);
1789 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1790 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1792 memset(&iocb, 0, sizeof(iocb));
1793 iocb.aio_fildes = fd;
1794 iocb.aio_sigevent.sigev_notify_kqueue = kq;
1795 iocb.aio_sigevent.sigev_value.sival_ptr = (void*)0xdeadbeef;
1796 iocb.aio_sigevent.sigev_notify_kevent_flags = EV_ONESHOT;
1797 iocb.aio_sigevent.sigev_notify = SIGEV_KEVENT;
1799 ATF_CHECK_EQ(0, aio_fsync(O_SYNC, &iocb));
1801 nevents = kevent(kq, NULL, 0, events, 1, NULL);
1802 ATF_CHECK_EQ(1, nevents);
1803 ATF_CHECK_EQ(events[0].ident, (uintptr_t) &iocb);
1804 ATF_CHECK_EQ(events[0].filter, EVFILT_AIO);
1805 ATF_CHECK_EQ(events[0].flags, EV_EOF | EV_ONESHOT);
1806 ATF_CHECK_EQ(events[0].fflags, 0);
1807 ATF_CHECK_EQ(events[0].data, 0);
1808 ATF_CHECK_EQ((uintptr_t)events[0].udata, 0xdeadbeef);
1811 * Even though we haven't called aio_return, kevent will not return the
1812 * event again due to EV_ONESHOT.
1815 timeout.tv_nsec = 100000000;
1816 nevents = kevent(kq, NULL, 0, events, 1, &timeout);
1817 ATF_CHECK_EQ(0, nevents);
1819 ATF_CHECK_EQ(0, aio_return(&iocb));
1825 // aio_writev and aio_readv should still work even if the iovcnt is greater
1826 // than the number of buffered AIO operations permitted per process.
1827 ATF_TC_WITH_CLEANUP(vectored_big_iovcnt);
1828 ATF_TC_HEAD(vectored_big_iovcnt, tc)
1830 atf_tc_set_md_var(tc, "descr",
1831 "Vectored AIO should still work even if the iovcnt is greater than "
1832 "the number of buffered AIO operations permitted by the process");
1833 atf_tc_set_md_var(tc, "require.user", "root");
1835 ATF_TC_BODY(vectored_big_iovcnt, tc)
1839 ssize_t len, buflen;
1841 const char *oid = "vfs.aio.max_buf_aio";
1845 ssize_t sysctl_len = sizeof(max_buf_aio);
1847 ATF_REQUIRE_KERNEL_MODULE("aio");
1848 ATF_REQUIRE_UNSAFE_AIO();
1850 if (sysctlbyname(oid, &max_buf_aio, &sysctl_len, NULL, 0) == -1)
1851 atf_libc_error(errno, "Failed to read %s", oid);
1854 buflen = 512 * (max_buf_aio + 1);
1855 buffer = malloc(buflen);
1856 aio_fill_buffer(buffer, buflen, seed);
1857 iov = calloc(max_buf_aio + 1, sizeof(struct iovec));
1859 fd = aio_md_setup();
1861 bzero(&aio, sizeof(aio));
1862 aio.aio_fildes = fd;
1864 for (i = 0; i < max_buf_aio + 1; i++) {
1865 iov[i].iov_base = &buffer[i * 512];
1866 iov[i].iov_len = 512;
1869 aio.aio_iovcnt = max_buf_aio + 1;
1871 if (aio_writev(&aio) < 0)
1872 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1876 atf_tc_fail("aio failed: %s", strerror(errno));
1879 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
1881 bzero(&aio, sizeof(aio));
1882 aio.aio_fildes = fd;
1885 aio.aio_iovcnt = max_buf_aio + 1;
1887 if (aio_readv(&aio) < 0)
1888 atf_tc_fail("aio_readv failed: %s", strerror(errno));
1892 atf_tc_fail("aio failed: %s", strerror(errno));
1895 atf_tc_fail("aio short read (%jd)", (intmax_t)len);
1897 if (aio_test_buffer(buffer, buflen, seed) == 0)
1898 atf_tc_fail("buffer mismatched");
1902 ATF_TC_CLEANUP(vectored_big_iovcnt, tc)
1907 ATF_TC_WITHOUT_HEAD(vectored_file_poll);
1908 ATF_TC_BODY(vectored_file_poll, tc)
1910 aio_file_test(poll, NULL, true);
1913 ATF_TC_WITHOUT_HEAD(vectored_thread);
1914 ATF_TC_BODY(vectored_thread, tc)
1916 aio_file_test(poll_signaled, setup_thread(), true);
1919 ATF_TC_WITH_CLEANUP(vectored_md_poll);
1920 ATF_TC_HEAD(vectored_md_poll, tc)
1922 atf_tc_set_md_var(tc, "require.user", "root");
1924 ATF_TC_BODY(vectored_md_poll, tc)
1926 aio_md_test(poll, NULL, true);
1928 ATF_TC_CLEANUP(vectored_md_poll, tc)
1933 ATF_TC_WITHOUT_HEAD(vectored_socket_poll);
1934 ATF_TC_BODY(vectored_socket_poll, tc)
1936 aio_unix_socketpair_test(poll, NULL, true);
1939 // aio_writev and aio_readv should still work even if the iov contains elements
1940 // that aren't a multiple of the device's sector size, and even if the total
1941 // amount if I/O _is_ a multiple of the device's sector size.
1942 ATF_TC_WITH_CLEANUP(vectored_unaligned);
1943 ATF_TC_HEAD(vectored_unaligned, tc)
1945 atf_tc_set_md_var(tc, "descr",
1946 "Vectored AIO should still work even if the iov contains elements "
1947 "that aren't a multiple of the sector size.");
1948 atf_tc_set_md_var(tc, "require.user", "root");
1950 ATF_TC_BODY(vectored_unaligned, tc)
1952 struct aio_context ac;
1954 struct iovec iov[3];
1955 ssize_t len, total_len;
1958 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false))
1959 atf_tc_skip("https://bugs.freebsd.org/258766");
1961 ATF_REQUIRE_KERNEL_MODULE("aio");
1962 ATF_REQUIRE_UNSAFE_AIO();
1965 * Use a zvol with volmode=dev, so it will allow .d_write with
1966 * unaligned uio. geom devices use physio, which doesn't allow that.
1968 fd = aio_zvol_setup(atf_tc_get_ident(tc));
1969 aio_context_init(&ac, fd, fd, FILE_LEN);
1971 /* Break the buffer into 3 parts:
1972 * * A 4kB part, aligned to 4kB
1973 * * Two other parts that add up to 4kB:
1977 iov[0].iov_base = ac.ac_buffer;
1978 iov[0].iov_len = 4096;
1979 iov[1].iov_base = (void*)((uintptr_t)iov[0].iov_base + iov[0].iov_len);
1980 iov[1].iov_len = 256;
1981 iov[2].iov_base = (void*)((uintptr_t)iov[1].iov_base + iov[1].iov_len);
1982 iov[2].iov_len = 4096 - iov[1].iov_len;
1983 total_len = iov[0].iov_len + iov[1].iov_len + iov[2].iov_len;
1984 bzero(&aio, sizeof(aio));
1985 aio.aio_fildes = ac.ac_write_fd;
1990 if (aio_writev(&aio) < 0)
1991 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1995 atf_tc_fail("aio failed: %s", strerror(errno));
1997 if (len != total_len)
1998 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
2000 bzero(&aio, sizeof(aio));
2001 aio.aio_fildes = ac.ac_read_fd;
2006 if (aio_readv(&aio) < 0)
2007 atf_tc_fail("aio_readv failed: %s", strerror(errno));
2010 ATF_REQUIRE_MSG(aio_test_buffer(ac.ac_buffer, total_len,
2011 ac.ac_seed) != 0, "aio_test_buffer: internal error");
2015 ATF_TC_CLEANUP(vectored_unaligned, tc)
2017 aio_zvol_cleanup(atf_tc_get_ident(tc));
2021 aio_zvol_test(completion comp, struct sigevent *sev, bool vectored,
2024 struct aio_context ac;
2027 fd = aio_zvol_setup(unique);
2028 aio_context_init(&ac, fd, fd, MD_LEN);
2030 aio_writev_test(&ac, comp, sev);
2031 aio_readv_test(&ac, comp, sev);
2033 aio_write_test(&ac, comp, sev);
2034 aio_read_test(&ac, comp, sev);
2041 * Note that unlike md, the zvol is not a geom device, does not allow unmapped
2042 * buffers, and does not use physio.
2044 ATF_TC_WITH_CLEANUP(vectored_zvol_poll);
2045 ATF_TC_HEAD(vectored_zvol_poll, tc)
2047 atf_tc_set_md_var(tc, "require.user", "root");
2049 ATF_TC_BODY(vectored_zvol_poll, tc)
2051 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false))
2052 atf_tc_skip("https://bugs.freebsd.org/258766");
2053 aio_zvol_test(poll, NULL, true, atf_tc_get_ident(tc));
2055 ATF_TC_CLEANUP(vectored_zvol_poll, tc)
2057 aio_zvol_cleanup(atf_tc_get_ident(tc));
2063 /* Test every file type with every completion method */
2064 ATF_TP_ADD_TC(tp, file_kq);
2065 ATF_TP_ADD_TC(tp, file_poll);
2066 ATF_TP_ADD_TC(tp, file_signal);
2067 ATF_TP_ADD_TC(tp, file_suspend);
2068 ATF_TP_ADD_TC(tp, file_thread);
2069 ATF_TP_ADD_TC(tp, file_waitcomplete);
2070 ATF_TP_ADD_TC(tp, fifo_kq);
2071 ATF_TP_ADD_TC(tp, fifo_poll);
2072 ATF_TP_ADD_TC(tp, fifo_signal);
2073 ATF_TP_ADD_TC(tp, fifo_suspend);
2074 ATF_TP_ADD_TC(tp, fifo_thread);
2075 ATF_TP_ADD_TC(tp, fifo_waitcomplete);
2076 ATF_TP_ADD_TC(tp, socket_kq);
2077 ATF_TP_ADD_TC(tp, socket_poll);
2078 ATF_TP_ADD_TC(tp, socket_signal);
2079 ATF_TP_ADD_TC(tp, socket_suspend);
2080 ATF_TP_ADD_TC(tp, socket_thread);
2081 ATF_TP_ADD_TC(tp, socket_waitcomplete);
2082 ATF_TP_ADD_TC(tp, pty_kq);
2083 ATF_TP_ADD_TC(tp, pty_poll);
2084 ATF_TP_ADD_TC(tp, pty_signal);
2085 ATF_TP_ADD_TC(tp, pty_suspend);
2086 ATF_TP_ADD_TC(tp, pty_thread);
2087 ATF_TP_ADD_TC(tp, pty_waitcomplete);
2088 ATF_TP_ADD_TC(tp, pipe_kq);
2089 ATF_TP_ADD_TC(tp, pipe_poll);
2090 ATF_TP_ADD_TC(tp, pipe_signal);
2091 ATF_TP_ADD_TC(tp, pipe_suspend);
2092 ATF_TP_ADD_TC(tp, pipe_thread);
2093 ATF_TP_ADD_TC(tp, pipe_waitcomplete);
2094 ATF_TP_ADD_TC(tp, md_kq);
2095 ATF_TP_ADD_TC(tp, md_poll);
2096 ATF_TP_ADD_TC(tp, md_signal);
2097 ATF_TP_ADD_TC(tp, md_suspend);
2098 ATF_TP_ADD_TC(tp, md_thread);
2099 ATF_TP_ADD_TC(tp, md_waitcomplete);
2101 /* Various special cases */
2102 ATF_TP_ADD_TC(tp, aio_fsync_errors);
2103 ATF_TP_ADD_TC(tp, aio_fsync_sync_test);
2104 ATF_TP_ADD_TC(tp, aio_fsync_dsync_test);
2105 ATF_TP_ADD_TC(tp, aio_large_read_test);
2106 ATF_TP_ADD_TC(tp, aio_socket_two_reads);
2107 ATF_TP_ADD_TC(tp, aio_socket_blocking_short_write);
2108 ATF_TP_ADD_TC(tp, aio_socket_blocking_short_write_vectored);
2109 ATF_TP_ADD_TC(tp, aio_socket_listen_fail);
2110 ATF_TP_ADD_TC(tp, aio_socket_listen_pending);
2111 ATF_TP_ADD_TC(tp, aio_socket_short_write_cancel);
2112 ATF_TP_ADD_TC(tp, aio_socket_shutdown);
2113 ATF_TP_ADD_TC(tp, aio_writev_dos_iov_len);
2114 ATF_TP_ADD_TC(tp, aio_writev_dos_iovcnt);
2115 ATF_TP_ADD_TC(tp, aio_writev_efault);
2116 ATF_TP_ADD_TC(tp, aio_writev_empty_file_poll);
2117 ATF_TP_ADD_TC(tp, aio_writev_empty_file_signal);
2118 ATF_TP_ADD_TC(tp, ev_oneshot);
2119 ATF_TP_ADD_TC(tp, vectored_big_iovcnt);
2120 ATF_TP_ADD_TC(tp, vectored_file_poll);
2121 ATF_TP_ADD_TC(tp, vectored_md_poll);
2122 ATF_TP_ADD_TC(tp, vectored_zvol_poll);
2123 ATF_TP_ADD_TC(tp, vectored_unaligned);
2124 ATF_TP_ADD_TC(tp, vectored_socket_poll);
2125 ATF_TP_ADD_TC(tp, vectored_thread);
2127 return (atf_no_error());