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). For each file
36 * descriptor type, several completion methods are tested. This test program
37 * does not attempt to exercise error cases or more subtle asynchronous
38 * behavior, just make sure that the basic operations work on some basic object
42 #include <sys/param.h>
43 #include <sys/mdioctl.h>
44 #include <sys/module.h>
45 #include <sys/resource.h>
46 #include <sys/socket.h>
56 #include <semaphore.h>
67 #include "freebsd_test_suite/macros.h"
71 * GLOBAL_MAX sets the largest usable buffer size to be read and written, as
72 * it sizes ac_buffer in the aio_context structure. It is also the default
73 * size for file I/O. For other types, we use smaller blocks or we risk
74 * blocking (and we run in a single process/thread so that would be bad).
76 #define GLOBAL_MAX 16384
78 #define BUFFER_MAX GLOBAL_MAX
81 * A completion function will block until the aio has completed, then return
82 * the result of the aio. errno will be set appropriately.
84 typedef ssize_t (*completion)(struct aiocb*);
87 int ac_read_fd, ac_write_fd;
89 char ac_buffer[GLOBAL_MAX];
94 static sem_t completions;
98 * Fill a buffer given a seed that can be fed into srandom() to initialize
99 * the PRNG in a repeatable manner.
102 aio_fill_buffer(char *buffer, int len, long seed)
108 for (i = 0; i < len; i++) {
109 ch = random() & 0xff;
115 * Test that a buffer matches a given seed. See aio_fill_buffer(). Return
116 * (1) on a match, (0) on a mismatch.
119 aio_test_buffer(char *buffer, int len, long seed)
125 for (i = 0; i < len; i++) {
126 ch = random() & 0xff;
134 * Initialize a testing context given the file descriptors provided by the
138 aio_context_init(struct aio_context *ac, int read_fd,
139 int write_fd, int buflen)
142 ATF_REQUIRE_MSG(buflen <= BUFFER_MAX,
143 "aio_context_init: buffer too large (%d > %d)",
145 bzero(ac, sizeof(*ac));
146 ac->ac_read_fd = read_fd;
147 ac->ac_write_fd = write_fd;
148 ac->ac_buflen = buflen;
150 ac->ac_seed = random();
151 aio_fill_buffer(ac->ac_buffer, buflen, ac->ac_seed);
152 ATF_REQUIRE_MSG(aio_test_buffer(ac->ac_buffer, buflen,
153 ac->ac_seed) != 0, "aio_test_buffer: internal error");
157 poll(struct aiocb *aio)
161 while ((error = aio_error(aio)) == EINPROGRESS)
166 return (aio_return(aio));
170 sigusr1_handler(int sig __unused)
172 ATF_REQUIRE_EQ(0, sem_post(&completions));
176 thr_handler(union sigval sv __unused)
178 ATF_REQUIRE_EQ(0, sem_post(&completions));
182 poll_signaled(struct aiocb *aio)
186 ATF_REQUIRE_EQ(0, sem_wait(&completions));
187 error = aio_error(aio);
193 return (aio_return(aio));
200 * Setup a signal handler for signal delivery tests
201 * This isn't thread safe, but it's ok since ATF runs each testcase in a
204 static struct sigevent*
207 static struct sigevent sev;
209 ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
210 sev.sigev_notify = SIGEV_SIGNAL;
211 sev.sigev_signo = SIGUSR1;
212 ATF_REQUIRE(SIG_ERR != signal(SIGUSR1, sigusr1_handler));
217 * Setup a thread for thread delivery tests
218 * This isn't thread safe, but it's ok since ATF runs each testcase in a
221 static struct sigevent*
224 static struct sigevent sev;
226 ATF_REQUIRE_EQ(0, sem_init(&completions, false, 0));
227 sev.sigev_notify = SIGEV_THREAD;
228 sev.sigev_notify_function = thr_handler;
229 sev.sigev_notify_attributes = NULL;
234 suspend(struct aiocb *aio)
236 const struct aiocb *const iocbs[] = {aio};
239 error = aio_suspend(iocbs, 1, NULL);
241 return (aio_return(aio));
247 waitcomplete(struct aiocb *aio)
252 ret = aio_waitcomplete(&aiop, NULL);
253 ATF_REQUIRE_EQ(aio, aiop);
258 * Perform a simple write test of our initialized data buffer to the provided
262 aio_write_test(struct aio_context *ac, completion comp, struct sigevent *sev)
267 bzero(&aio, sizeof(aio));
268 aio.aio_buf = ac->ac_buffer;
269 aio.aio_nbytes = ac->ac_buflen;
270 aio.aio_fildes = ac->ac_write_fd;
273 aio.aio_sigevent = *sev;
275 if (aio_write(&aio) < 0)
276 atf_tc_fail("aio_write failed: %s", strerror(errno));
280 atf_tc_fail("aio failed: %s", strerror(errno));
282 if (len != ac->ac_buflen)
283 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
287 * Perform a vectored I/O test of our initialized data buffer to the provided
290 * To vectorize the linear buffer, chop it up into two pieces of dissimilar
291 * size, and swap their offsets.
294 aio_writev_test(struct aio_context *ac, completion comp, struct sigevent *sev)
301 bzero(&aio, sizeof(aio));
303 aio.aio_fildes = ac->ac_write_fd;
305 len0 = ac->ac_buflen * 3 / 4;
306 len1 = ac->ac_buflen / 4;
307 iov[0].iov_base = ac->ac_buffer + len1;
308 iov[0].iov_len = len0;
309 iov[1].iov_base = ac->ac_buffer;
310 iov[1].iov_len = len1;
314 aio.aio_sigevent = *sev;
316 if (aio_writev(&aio) < 0)
317 atf_tc_fail("aio_writev failed: %s", strerror(errno));
321 atf_tc_fail("aio failed: %s", strerror(errno));
323 if (len != ac->ac_buflen)
324 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
328 * Perform a simple read test of our initialized data buffer from the
329 * provided file descriptor.
332 aio_read_test(struct aio_context *ac, completion comp, struct sigevent *sev)
337 bzero(ac->ac_buffer, ac->ac_buflen);
338 bzero(&aio, sizeof(aio));
339 aio.aio_buf = ac->ac_buffer;
340 aio.aio_nbytes = ac->ac_buflen;
341 aio.aio_fildes = ac->ac_read_fd;
344 aio.aio_sigevent = *sev;
346 if (aio_read(&aio) < 0)
347 atf_tc_fail("aio_read failed: %s", strerror(errno));
351 atf_tc_fail("aio failed: %s", strerror(errno));
353 ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
354 "aio short read (%jd)", (intmax_t)len);
356 if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
357 atf_tc_fail("buffer mismatched");
361 aio_readv_test(struct aio_context *ac, completion comp, struct sigevent *sev)
368 bzero(ac->ac_buffer, ac->ac_buflen);
369 bzero(&aio, sizeof(aio));
370 aio.aio_fildes = ac->ac_read_fd;
372 len0 = ac->ac_buflen * 3 / 4;
373 len1 = ac->ac_buflen / 4;
374 iov[0].iov_base = ac->ac_buffer + len1;
375 iov[0].iov_len = len0;
376 iov[1].iov_base = ac->ac_buffer;
377 iov[1].iov_len = len1;
381 aio.aio_sigevent = *sev;
383 if (aio_readv(&aio) < 0)
384 atf_tc_fail("aio_read failed: %s", strerror(errno));
388 atf_tc_fail("aio failed: %s", strerror(errno));
390 ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
391 "aio short read (%jd)", (intmax_t)len);
393 if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
394 atf_tc_fail("buffer mismatched");
398 * Series of type-specific tests for AIO. For now, we just make sure we can
399 * issue a write and then a read to each type. We assume that once a write
400 * is issued, a read can follow.
404 * Test with a classic file. Assumes we can create a moderate size temporary
407 #define FILE_LEN GLOBAL_MAX
408 #define FILE_PATHNAME "testfile"
411 aio_file_test(completion comp, struct sigevent *sev, bool vectored)
413 struct aio_context ac;
416 ATF_REQUIRE_KERNEL_MODULE("aio");
417 ATF_REQUIRE_UNSAFE_AIO();
419 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
420 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
422 aio_context_init(&ac, fd, fd, FILE_LEN);
424 aio_writev_test(&ac, comp, sev);
425 aio_readv_test(&ac, comp, sev);
427 aio_write_test(&ac, comp, sev);
428 aio_read_test(&ac, comp, sev);
433 ATF_TC_WITHOUT_HEAD(file_poll);
434 ATF_TC_BODY(file_poll, tc)
436 aio_file_test(poll, NULL, false);
439 ATF_TC_WITHOUT_HEAD(file_signal);
440 ATF_TC_BODY(file_signal, tc)
442 aio_file_test(poll_signaled, setup_signal(), false);
445 ATF_TC_WITHOUT_HEAD(file_suspend);
446 ATF_TC_BODY(file_suspend, tc)
448 aio_file_test(suspend, NULL, false);
451 ATF_TC_WITHOUT_HEAD(file_thread);
452 ATF_TC_BODY(file_thread, tc)
454 aio_file_test(poll_signaled, setup_thread(), false);
457 ATF_TC_WITHOUT_HEAD(file_waitcomplete);
458 ATF_TC_BODY(file_waitcomplete, tc)
460 aio_file_test(waitcomplete, NULL, false);
464 #define FIFO_PATHNAME "testfifo"
467 aio_fifo_test(completion comp, struct sigevent *sev)
469 int error, read_fd = -1, write_fd = -1;
470 struct aio_context ac;
472 ATF_REQUIRE_KERNEL_MODULE("aio");
473 ATF_REQUIRE_UNSAFE_AIO();
475 ATF_REQUIRE_MSG(mkfifo(FIFO_PATHNAME, 0600) != -1,
476 "mkfifo failed: %s", strerror(errno));
478 read_fd = open(FIFO_PATHNAME, O_RDONLY | O_NONBLOCK);
482 atf_tc_fail("read_fd open failed: %s",
486 write_fd = open(FIFO_PATHNAME, O_WRONLY);
487 if (write_fd == -1) {
490 atf_tc_fail("write_fd open failed: %s",
494 aio_context_init(&ac, read_fd, write_fd, FIFO_LEN);
495 aio_write_test(&ac, comp, sev);
496 aio_read_test(&ac, comp, sev);
502 ATF_TC_WITHOUT_HEAD(fifo_poll);
503 ATF_TC_BODY(fifo_poll, tc)
505 aio_fifo_test(poll, NULL);
508 ATF_TC_WITHOUT_HEAD(fifo_signal);
509 ATF_TC_BODY(fifo_signal, tc)
511 aio_fifo_test(poll_signaled, setup_signal());
514 ATF_TC_WITHOUT_HEAD(fifo_suspend);
515 ATF_TC_BODY(fifo_suspend, tc)
517 aio_fifo_test(suspend, NULL);
520 ATF_TC_WITHOUT_HEAD(fifo_thread);
521 ATF_TC_BODY(fifo_thread, tc)
523 aio_fifo_test(poll_signaled, setup_thread());
526 ATF_TC_WITHOUT_HEAD(fifo_waitcomplete);
527 ATF_TC_BODY(fifo_waitcomplete, tc)
529 aio_fifo_test(waitcomplete, NULL);
532 #define UNIX_SOCKETPAIR_LEN 256
534 aio_unix_socketpair_test(completion comp, struct sigevent *sev, bool vectored)
536 struct aio_context ac;
537 struct rusage ru_before, ru_after;
540 ATF_REQUIRE_KERNEL_MODULE("aio");
542 ATF_REQUIRE_MSG(socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) != -1,
543 "socketpair failed: %s", strerror(errno));
545 aio_context_init(&ac, sockets[0], sockets[1], UNIX_SOCKETPAIR_LEN);
546 ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_before) != -1,
547 "getrusage failed: %s", strerror(errno));
549 aio_writev_test(&ac, comp, sev);
550 aio_readv_test(&ac, comp, sev);
552 aio_write_test(&ac, comp, sev);
553 aio_read_test(&ac, comp, sev);
555 ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_after) != -1,
556 "getrusage failed: %s", strerror(errno));
557 ATF_REQUIRE(ru_after.ru_msgsnd == ru_before.ru_msgsnd + 1);
558 ATF_REQUIRE(ru_after.ru_msgrcv == ru_before.ru_msgrcv + 1);
564 ATF_TC_WITHOUT_HEAD(socket_poll);
565 ATF_TC_BODY(socket_poll, tc)
567 aio_unix_socketpair_test(poll, NULL, false);
570 ATF_TC_WITHOUT_HEAD(socket_signal);
571 ATF_TC_BODY(socket_signal, tc)
573 aio_unix_socketpair_test(poll_signaled, setup_signal(), false);
576 ATF_TC_WITHOUT_HEAD(socket_suspend);
577 ATF_TC_BODY(socket_suspend, tc)
579 aio_unix_socketpair_test(suspend, NULL, false);
582 ATF_TC_WITHOUT_HEAD(socket_thread);
583 ATF_TC_BODY(socket_thread, tc)
585 aio_unix_socketpair_test(poll_signaled, setup_thread(), false);
588 ATF_TC_WITHOUT_HEAD(socket_waitcomplete);
589 ATF_TC_BODY(socket_waitcomplete, tc)
591 aio_unix_socketpair_test(waitcomplete, NULL, false);
601 aio_pty_test(completion comp, struct sigevent *sev)
603 struct aio_context ac;
604 int read_fd, write_fd;
608 ATF_REQUIRE_KERNEL_MODULE("aio");
609 ATF_REQUIRE_UNSAFE_AIO();
611 ATF_REQUIRE_MSG(openpty(&read_fd, &write_fd, NULL, NULL, NULL) == 0,
612 "openpty failed: %s", strerror(errno));
615 if (tcgetattr(write_fd, &ts) < 0) {
618 atf_tc_fail("tcgetattr failed: %s", strerror(errno));
621 if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
624 atf_tc_fail("tcsetattr failed: %s", strerror(errno));
626 aio_context_init(&ac, read_fd, write_fd, PTY_LEN);
628 aio_write_test(&ac, comp, sev);
629 aio_read_test(&ac, comp, sev);
635 ATF_TC_WITHOUT_HEAD(pty_poll);
636 ATF_TC_BODY(pty_poll, tc)
638 aio_pty_test(poll, NULL);
641 ATF_TC_WITHOUT_HEAD(pty_signal);
642 ATF_TC_BODY(pty_signal, tc)
644 aio_pty_test(poll_signaled, setup_signal());
647 ATF_TC_WITHOUT_HEAD(pty_suspend);
648 ATF_TC_BODY(pty_suspend, tc)
650 aio_pty_test(suspend, NULL);
653 ATF_TC_WITHOUT_HEAD(pty_thread);
654 ATF_TC_BODY(pty_thread, tc)
656 aio_pty_test(poll_signaled, setup_thread());
659 ATF_TC_WITHOUT_HEAD(pty_waitcomplete);
660 ATF_TC_BODY(pty_waitcomplete, tc)
662 aio_pty_test(waitcomplete, NULL);
667 aio_pipe_test(completion comp, struct sigevent *sev)
669 struct aio_context ac;
672 ATF_REQUIRE_KERNEL_MODULE("aio");
673 ATF_REQUIRE_UNSAFE_AIO();
675 ATF_REQUIRE_MSG(pipe(pipes) != -1,
676 "pipe failed: %s", strerror(errno));
678 aio_context_init(&ac, pipes[0], pipes[1], PIPE_LEN);
679 aio_write_test(&ac, comp, sev);
680 aio_read_test(&ac, comp, sev);
686 ATF_TC_WITHOUT_HEAD(pipe_poll);
687 ATF_TC_BODY(pipe_poll, tc)
689 aio_pipe_test(poll, NULL);
692 ATF_TC_WITHOUT_HEAD(pipe_signal);
693 ATF_TC_BODY(pipe_signal, tc)
695 aio_pipe_test(poll_signaled, setup_signal());
698 ATF_TC_WITHOUT_HEAD(pipe_suspend);
699 ATF_TC_BODY(pipe_suspend, tc)
701 aio_pipe_test(suspend, NULL);
704 ATF_TC_WITHOUT_HEAD(pipe_thread);
705 ATF_TC_BODY(pipe_thread, tc)
707 aio_pipe_test(poll_signaled, setup_thread());
710 ATF_TC_WITHOUT_HEAD(pipe_waitcomplete);
711 ATF_TC_BODY(pipe_waitcomplete, tc)
713 aio_pipe_test(waitcomplete, NULL);
716 #define MD_LEN GLOBAL_MAX
717 #define MDUNIT_LINK "mdunit_link"
722 int error, fd, mdctl_fd, unit;
723 char pathname[PATH_MAX];
724 struct md_ioctl mdio;
727 ATF_REQUIRE_KERNEL_MODULE("aio");
729 mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
730 ATF_REQUIRE_MSG(mdctl_fd != -1,
731 "opening /dev/%s failed: %s", MDCTL_NAME, strerror(errno));
733 bzero(&mdio, sizeof(mdio));
734 mdio.md_version = MDIOVERSION;
735 mdio.md_type = MD_MALLOC;
736 mdio.md_options = MD_AUTOUNIT | MD_COMPRESS;
737 mdio.md_mediasize = GLOBAL_MAX;
738 mdio.md_sectorsize = 512;
739 strlcpy(buf, __func__, sizeof(buf));
742 if (ioctl(mdctl_fd, MDIOCATTACH, &mdio) < 0) {
745 atf_tc_fail("ioctl MDIOCATTACH failed: %s", strerror(errno));
749 /* Store the md unit number in a symlink for future cleanup */
751 snprintf(buf, sizeof(buf), "%d", unit);
752 ATF_REQUIRE_EQ(0, symlink(buf, MDUNIT_LINK));
753 snprintf(pathname, PATH_MAX, "/dev/md%d", unit);
754 fd = open(pathname, O_RDWR);
755 ATF_REQUIRE_MSG(fd != -1,
756 "opening %s failed: %s", pathname, strerror(errno));
764 struct md_ioctl mdio;
765 int mdctl_fd, n, unit;
768 mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
770 fprintf(stderr, "opening /dev/%s failed: %s\n", MDCTL_NAME,
774 n = readlink(MDUNIT_LINK, buf, sizeof(buf) - 1);
777 if (sscanf(buf, "%d", &unit) == 1 && unit >= 0) {
778 bzero(&mdio, sizeof(mdio));
779 mdio.md_version = MDIOVERSION;
781 if (ioctl(mdctl_fd, MDIOCDETACH, &mdio) == -1) {
783 "ioctl MDIOCDETACH unit %d failed: %s\n",
784 unit, strerror(errno));
793 aio_md_test(completion comp, struct sigevent *sev, bool vectored)
795 struct aio_context ac;
799 aio_context_init(&ac, fd, fd, MD_LEN);
801 aio_writev_test(&ac, comp, sev);
802 aio_readv_test(&ac, comp, sev);
804 aio_write_test(&ac, comp, sev);
805 aio_read_test(&ac, comp, sev);
811 ATF_TC_WITH_CLEANUP(md_poll);
812 ATF_TC_HEAD(md_poll, tc)
815 atf_tc_set_md_var(tc, "require.user", "root");
817 ATF_TC_BODY(md_poll, tc)
819 aio_md_test(poll, NULL, false);
821 ATF_TC_CLEANUP(md_poll, tc)
826 ATF_TC_WITH_CLEANUP(md_signal);
827 ATF_TC_HEAD(md_signal, tc)
830 atf_tc_set_md_var(tc, "require.user", "root");
832 ATF_TC_BODY(md_signal, tc)
834 aio_md_test(poll_signaled, setup_signal(), false);
836 ATF_TC_CLEANUP(md_signal, tc)
841 ATF_TC_WITH_CLEANUP(md_suspend);
842 ATF_TC_HEAD(md_suspend, tc)
845 atf_tc_set_md_var(tc, "require.user", "root");
847 ATF_TC_BODY(md_suspend, tc)
849 aio_md_test(suspend, NULL, false);
851 ATF_TC_CLEANUP(md_suspend, tc)
856 ATF_TC_WITH_CLEANUP(md_thread);
857 ATF_TC_HEAD(md_thread, tc)
860 atf_tc_set_md_var(tc, "require.user", "root");
862 ATF_TC_BODY(md_thread, tc)
864 aio_md_test(poll_signaled, setup_thread(), false);
866 ATF_TC_CLEANUP(md_thread, tc)
871 ATF_TC_WITH_CLEANUP(md_waitcomplete);
872 ATF_TC_HEAD(md_waitcomplete, tc)
875 atf_tc_set_md_var(tc, "require.user", "root");
877 ATF_TC_BODY(md_waitcomplete, tc)
879 aio_md_test(waitcomplete, NULL, false);
881 ATF_TC_CLEANUP(md_waitcomplete, tc)
886 #define ZVOL_VDEV_PATHNAME "test_vdev"
887 #define POOL_SIZE (1 << 28) /* 256 MB */
888 #define ZVOL_SIZE "64m"
889 #define POOL_NAME "aio_testpool"
890 #define ZVOL_NAME "aio_testvol"
903 ATF_REQUIRE_KERNEL_MODULE("aio");
904 ATF_REQUIRE_KERNEL_MODULE("zfs");
906 fd = open(ZVOL_VDEV_PATHNAME, O_RDWR | O_CREAT, 0600);
907 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
908 ATF_REQUIRE_EQ_MSG(0,
909 ftruncate(fd, POOL_SIZE), "ftruncate failed: %s", strerror(errno));
913 pidfile = fopen("pidfile", "w");
914 ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
915 fprintf(pidfile, "%d", pid);
918 snprintf(pool_name, sizeof(pool_name), POOL_NAME ".%d", pid);
919 snprintf(zvol_name, sizeof(zvol_name), "%s/" ZVOL_NAME, pool_name);
920 snprintf(cmd, sizeof(cmd), "zpool create %s $PWD/" ZVOL_VDEV_PATHNAME,
922 ATF_REQUIRE_EQ_MSG(0, system(cmd),
923 "zpool create failed: %s", strerror(errno));
924 snprintf(cmd, sizeof(cmd),
925 "zfs create -o volblocksize=8192 -o volmode=dev -V "
926 ZVOL_SIZE " %s", zvol_name);
927 ATF_REQUIRE_EQ_MSG(0, system(cmd),
928 "zfs create failed: %s", strerror(errno));
930 snprintf(devname, sizeof(devname), "/dev/zvol/%s", zvol_name);
932 fd = open(devname, O_RDWR);
933 } while (fd == -1 && errno == EINTR) ;
934 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
939 aio_zvol_cleanup(void)
945 pidfile = fopen("pidfile", "r");
946 if (pidfile == NULL && errno == ENOENT) {
947 /* Setup probably failed */
950 ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
951 ATF_REQUIRE_EQ(1, fscanf(pidfile, "%d", &testpid));
954 snprintf(cmd, sizeof(cmd), "zpool destroy " POOL_NAME ".%d", testpid);
959 ATF_TC_WITHOUT_HEAD(aio_large_read_test);
960 ATF_TC_BODY(aio_large_read_test, tc)
962 struct aiocb cb, *cbp;
970 ATF_REQUIRE_KERNEL_MODULE("aio");
971 ATF_REQUIRE_UNSAFE_AIO();
974 len = sizeof(clamped);
975 if (sysctlbyname("debug.iosize_max_clamp", &clamped, &len, NULL, 0) ==
977 atf_libc_error(errno, "Failed to read debug.iosize_max_clamp");
980 /* Determine the maximum supported read(2) size. */
987 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
988 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
990 unlink(FILE_PATHNAME);
992 memset(&cb, 0, sizeof(cb));
996 if (aio_read(&cb) == -1)
997 atf_tc_fail("aio_read() of maximum read size failed: %s",
1000 nread = aio_waitcomplete(&cbp, NULL);
1002 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1004 atf_tc_fail("aio_read() from empty file returned data: %zd",
1007 memset(&cb, 0, sizeof(cb));
1008 cb.aio_nbytes = len + 1;
1011 if (aio_read(&cb) == -1) {
1012 if (errno == EINVAL)
1014 atf_tc_fail("aio_read() of too large read size failed: %s",
1018 nread = aio_waitcomplete(&cbp, NULL);
1020 if (errno == EINVAL)
1022 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1024 atf_tc_fail("aio_read() of too large read size returned: %zd", nread);
1031 * This tests for a bug where arriving socket data can wakeup multiple
1032 * AIO read requests resulting in an uncancellable request.
1034 ATF_TC_WITHOUT_HEAD(aio_socket_two_reads);
1035 ATF_TC_BODY(aio_socket_two_reads, tc)
1046 ATF_REQUIRE_KERNEL_MODULE("aio");
1047 #if __FreeBSD_version < 1100101
1048 aft_tc_skip("kernel version %d is too old (%d required)",
1049 __FreeBSD_version, 1100101);
1052 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1054 /* Queue two read requests. */
1055 memset(&ioreq, 0, sizeof(ioreq));
1056 for (i = 0; i < nitems(ioreq); i++) {
1057 ioreq[i].iocb.aio_nbytes = sizeof(ioreq[i].buffer);
1058 ioreq[i].iocb.aio_fildes = s[0];
1059 ioreq[i].iocb.aio_buf = ioreq[i].buffer;
1060 ATF_REQUIRE(aio_read(&ioreq[i].iocb) == 0);
1063 /* Send a single byte. This should complete one request. */
1065 ATF_REQUIRE(write(s[1], &c, sizeof(c)) == 1);
1067 ATF_REQUIRE(aio_waitcomplete(&iocb, NULL) == 1);
1069 /* Determine which request completed and verify the data was read. */
1070 if (iocb == &ioreq[0].iocb)
1074 ATF_REQUIRE(ioreq[i].buffer[0] == c);
1079 * Try to cancel the other request. On broken systems this
1080 * will fail and the process will hang on exit.
1082 ATF_REQUIRE(aio_error(&ioreq[i].iocb) == EINPROGRESS);
1083 ATF_REQUIRE(aio_cancel(s[0], &ioreq[i].iocb) == AIO_CANCELED);
1090 aio_socket_blocking_short_write_test(bool vectored)
1092 struct aiocb iocb, *iocbp;
1093 struct iovec iov[2];
1096 int buffer_size, sb_size;
1100 ATF_REQUIRE_KERNEL_MODULE("aio");
1102 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1104 len = sizeof(sb_size);
1105 ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1107 ATF_REQUIRE(len == sizeof(sb_size));
1108 buffer_size = sb_size;
1110 ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1112 ATF_REQUIRE(len == sizeof(sb_size));
1113 if (sb_size > buffer_size)
1114 buffer_size = sb_size;
1117 * Use twice the size of the MAX(receive buffer, send buffer)
1118 * to ensure that the write is split up into multiple writes
1123 buffer[0] = malloc(buffer_size);
1124 ATF_REQUIRE(buffer[0] != NULL);
1125 buffer[1] = malloc(buffer_size);
1126 ATF_REQUIRE(buffer[1] != NULL);
1129 aio_fill_buffer(buffer[1], buffer_size, random());
1131 memset(&iocb, 0, sizeof(iocb));
1132 iocb.aio_fildes = s[1];
1134 iov[0].iov_base = buffer[1];
1135 iov[0].iov_len = buffer_size / 2 + 1;
1136 iov[1].iov_base = buffer[1] + buffer_size / 2 + 1;
1137 iov[1].iov_len = buffer_size / 2 - 1;
1139 iocb.aio_iovcnt = 2;
1140 r = aio_writev(&iocb);
1141 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1143 iocb.aio_buf = buffer[1];
1144 iocb.aio_nbytes = buffer_size;
1145 r = aio_write(&iocb);
1146 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1149 done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1150 ATF_REQUIRE(done == buffer_size);
1152 done = aio_waitcomplete(&iocbp, NULL);
1153 ATF_REQUIRE(iocbp == &iocb);
1154 ATF_REQUIRE(done == buffer_size);
1156 ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1163 * This test ensures that aio_write() on a blocking socket of a "large"
1164 * buffer does not return a short completion.
1166 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write);
1167 ATF_TC_BODY(aio_socket_blocking_short_write, tc)
1169 aio_socket_blocking_short_write_test(false);
1173 * Like aio_socket_blocking_short_write, but also tests that partially
1174 * completed vectored sends can be retried correctly.
1176 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write_vectored);
1177 ATF_TC_BODY(aio_socket_blocking_short_write_vectored, tc)
1179 aio_socket_blocking_short_write_test(true);
1183 * Verify that AIO requests fail when applied to a listening socket.
1185 ATF_TC_WITHOUT_HEAD(aio_socket_listen_fail);
1186 ATF_TC_BODY(aio_socket_listen_fail, tc)
1189 struct sockaddr_un sun;
1193 s = socket(AF_LOCAL, SOCK_STREAM, 0);
1194 ATF_REQUIRE(s != -1);
1196 memset(&sun, 0, sizeof(sun));
1197 snprintf(sun.sun_path, sizeof(sun.sun_path), "%s", "listen.XXXXXX");
1198 mktemp(sun.sun_path);
1199 sun.sun_family = AF_LOCAL;
1200 sun.sun_len = SUN_LEN(&sun);
1202 ATF_REQUIRE(bind(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) == 0);
1203 ATF_REQUIRE(listen(s, 5) == 0);
1205 memset(buf, 0, sizeof(buf));
1206 memset(&iocb, 0, sizeof(iocb));
1207 iocb.aio_fildes = s;
1209 iocb.aio_nbytes = sizeof(buf);
1211 ATF_REQUIRE_ERRNO(EINVAL, aio_read(&iocb) == -1);
1212 ATF_REQUIRE_ERRNO(EINVAL, aio_write(&iocb) == -1);
1214 ATF_REQUIRE(unlink(sun.sun_path) == 0);
1219 * Verify that listen(2) fails if a socket has pending AIO requests.
1221 ATF_TC_WITHOUT_HEAD(aio_socket_listen_pending);
1222 ATF_TC_BODY(aio_socket_listen_pending, tc)
1225 struct sockaddr_un sun;
1229 s = socket(AF_LOCAL, SOCK_STREAM, 0);
1230 ATF_REQUIRE(s != -1);
1232 memset(&sun, 0, sizeof(sun));
1233 snprintf(sun.sun_path, sizeof(sun.sun_path), "%s", "listen.XXXXXX");
1234 mktemp(sun.sun_path);
1235 sun.sun_family = AF_LOCAL;
1236 sun.sun_len = SUN_LEN(&sun);
1238 ATF_REQUIRE(bind(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) == 0);
1240 memset(buf, 0, sizeof(buf));
1241 memset(&iocb, 0, sizeof(iocb));
1242 iocb.aio_fildes = s;
1244 iocb.aio_nbytes = sizeof(buf);
1245 ATF_REQUIRE(aio_read(&iocb) == 0);
1247 ATF_REQUIRE_ERRNO(EINVAL, listen(s, 5) == -1);
1249 ATF_REQUIRE(aio_cancel(s, &iocb) != -1);
1251 ATF_REQUIRE(unlink(sun.sun_path) == 0);
1256 * This test verifies that cancelling a partially completed socket write
1257 * returns a short write rather than ECANCELED.
1259 ATF_TC_WITHOUT_HEAD(aio_socket_short_write_cancel);
1260 ATF_TC_BODY(aio_socket_short_write_cancel, tc)
1262 struct aiocb iocb, *iocbp;
1265 int buffer_size, sb_size;
1269 ATF_REQUIRE_KERNEL_MODULE("aio");
1271 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1273 len = sizeof(sb_size);
1274 ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1276 ATF_REQUIRE(len == sizeof(sb_size));
1277 buffer_size = sb_size;
1279 ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1281 ATF_REQUIRE(len == sizeof(sb_size));
1282 if (sb_size > buffer_size)
1283 buffer_size = sb_size;
1286 * Use three times the size of the MAX(receive buffer, send
1287 * buffer) for the write to ensure that the write is split up
1288 * into multiple writes internally. The recv() ensures that
1289 * the write has partially completed, but a remaining size of
1290 * two buffers should ensure that the write has not completed
1291 * fully when it is cancelled.
1293 buffer[0] = malloc(buffer_size);
1294 ATF_REQUIRE(buffer[0] != NULL);
1295 buffer[1] = malloc(buffer_size * 3);
1296 ATF_REQUIRE(buffer[1] != NULL);
1299 aio_fill_buffer(buffer[1], buffer_size * 3, random());
1301 memset(&iocb, 0, sizeof(iocb));
1302 iocb.aio_fildes = s[1];
1303 iocb.aio_buf = buffer[1];
1304 iocb.aio_nbytes = buffer_size * 3;
1305 ATF_REQUIRE(aio_write(&iocb) == 0);
1307 done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1308 ATF_REQUIRE(done == buffer_size);
1310 ATF_REQUIRE(aio_error(&iocb) == EINPROGRESS);
1311 ATF_REQUIRE(aio_cancel(s[1], &iocb) == AIO_NOTCANCELED);
1313 done = aio_waitcomplete(&iocbp, NULL);
1314 ATF_REQUIRE(iocbp == &iocb);
1315 ATF_REQUIRE(done >= buffer_size && done <= buffer_size * 2);
1317 ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1324 * Test handling of aio_read() and aio_write() on shut-down sockets.
1326 ATF_TC_WITHOUT_HEAD(aio_socket_shutdown);
1327 ATF_TC_BODY(aio_socket_shutdown, tc)
1336 ATF_REQUIRE_KERNEL_MODULE("aio");
1338 ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1341 buffer = malloc(bsz);
1342 memset(buffer, 0, bsz);
1344 /* Put some data in s[0]'s recv buffer. */
1345 ATF_REQUIRE(send(s[1], buffer, bsz, 0) == (ssize_t)bsz);
1347 /* No more reading from s[0]. */
1348 ATF_REQUIRE(shutdown(s[0], SHUT_RD) != -1);
1350 ATF_REQUIRE(buffer != NULL);
1352 memset(&iocb, 0, sizeof(iocb));
1353 iocb.aio_fildes = s[0];
1354 iocb.aio_buf = buffer;
1355 iocb.aio_nbytes = bsz;
1356 ATF_REQUIRE(aio_read(&iocb) == 0);
1358 /* Expect to see zero bytes, analogous to recv(2). */
1359 while ((error = aio_error(&iocb)) == EINPROGRESS)
1361 ATF_REQUIRE_MSG(error == 0, "aio_error() returned %d", error);
1362 len = aio_return(&iocb);
1363 ATF_REQUIRE_MSG(len == 0, "read job returned %zd bytes", len);
1365 /* No more writing to s[1]. */
1366 ATF_REQUIRE(shutdown(s[1], SHUT_WR) != -1);
1368 /* Block SIGPIPE so that we can detect the error in-band. */
1370 sigaddset(&set, SIGPIPE);
1371 ATF_REQUIRE(sigprocmask(SIG_BLOCK, &set, NULL) == 0);
1373 memset(&iocb, 0, sizeof(iocb));
1374 iocb.aio_fildes = s[1];
1375 iocb.aio_buf = buffer;
1376 iocb.aio_nbytes = bsz;
1377 ATF_REQUIRE(aio_write(&iocb) == 0);
1379 /* Expect an error, analogous to send(2). */
1380 while ((error = aio_error(&iocb)) == EINPROGRESS)
1382 ATF_REQUIRE_MSG(error == EPIPE, "aio_error() returned %d", error);
1384 ATF_REQUIRE(close(s[0]) != -1);
1385 ATF_REQUIRE(close(s[1]) != -1);
1390 * test aio_fsync's behavior with bad inputs
1392 ATF_TC_WITHOUT_HEAD(aio_fsync_errors);
1393 ATF_TC_BODY(aio_fsync_errors, tc)
1398 ATF_REQUIRE_KERNEL_MODULE("aio");
1399 ATF_REQUIRE_UNSAFE_AIO();
1401 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1402 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1403 unlink(FILE_PATHNAME);
1405 /* aio_fsync should return EINVAL unless op is O_SYNC or O_DSYNC */
1406 memset(&iocb, 0, sizeof(iocb));
1407 iocb.aio_fildes = fd;
1408 ATF_CHECK_EQ(-1, aio_fsync(666, &iocb));
1409 ATF_CHECK_EQ(EINVAL, errno);
1411 /* aio_fsync should return EBADF if fd is not a valid descriptor */
1412 memset(&iocb, 0, sizeof(iocb));
1413 iocb.aio_fildes = 666;
1414 ATF_CHECK_EQ(-1, aio_fsync(O_SYNC, &iocb));
1415 ATF_CHECK_EQ(EBADF, errno);
1417 /* aio_fsync should return EINVAL if sigev_notify is invalid */
1418 memset(&iocb, 0, sizeof(iocb));
1419 iocb.aio_fildes = fd;
1420 iocb.aio_sigevent.sigev_notify = 666;
1421 ATF_CHECK_EQ(-1, aio_fsync(666, &iocb));
1422 ATF_CHECK_EQ(EINVAL, errno);
1426 * This test just performs a basic test of aio_fsync().
1429 aio_fsync_test(int op)
1431 struct aiocb synccb, *iocbp;
1442 ATF_REQUIRE_KERNEL_MODULE("aio");
1443 ATF_REQUIRE_UNSAFE_AIO();
1445 fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1446 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1447 unlink(FILE_PATHNAME);
1449 ATF_REQUIRE(fstat(fd, &sb) == 0);
1450 ATF_REQUIRE(sb.st_blksize != 0);
1451 ATF_REQUIRE(ftruncate(fd, sb.st_blksize * nitems(buffers)) == 0);
1454 * Queue several asynchronous write requests. Hopefully this
1455 * forces the aio_fsync() request to be deferred. There is no
1456 * reliable way to guarantee that however.
1459 for (i = 0; i < nitems(buffers); i++) {
1460 buffers[i].done = false;
1461 memset(&buffers[i].iocb, 0, sizeof(buffers[i].iocb));
1462 buffers[i].buffer = malloc(sb.st_blksize);
1463 aio_fill_buffer(buffers[i].buffer, sb.st_blksize, random());
1464 buffers[i].iocb.aio_fildes = fd;
1465 buffers[i].iocb.aio_buf = buffers[i].buffer;
1466 buffers[i].iocb.aio_nbytes = sb.st_blksize;
1467 buffers[i].iocb.aio_offset = sb.st_blksize * i;
1468 ATF_REQUIRE(aio_write(&buffers[i].iocb) == 0);
1471 /* Queue the aio_fsync request. */
1472 memset(&synccb, 0, sizeof(synccb));
1473 synccb.aio_fildes = fd;
1474 ATF_REQUIRE(aio_fsync(op, &synccb) == 0);
1476 /* Wait for requests to complete. */
1479 rval = aio_waitcomplete(&iocbp, NULL);
1480 ATF_REQUIRE(iocbp != NULL);
1481 if (iocbp == &synccb) {
1482 ATF_REQUIRE(rval == 0);
1486 for (i = 0; i < nitems(buffers); i++) {
1487 if (iocbp == &buffers[i].iocb) {
1488 ATF_REQUIRE(buffers[i].done == false);
1489 ATF_REQUIRE(rval == sb.st_blksize);
1490 buffers[i].done = true;
1495 ATF_REQUIRE_MSG(false, "unmatched AIO request");
1498 for (i = 0; i < nitems(buffers); i++)
1499 ATF_REQUIRE_MSG(buffers[i].done,
1500 "AIO request %u did not complete", i);
1505 ATF_TC_WITHOUT_HEAD(aio_fsync_sync_test);
1506 ATF_TC_BODY(aio_fsync_sync_test, tc)
1508 aio_fsync_test(O_SYNC);
1511 ATF_TC_WITHOUT_HEAD(aio_fsync_dsync_test);
1512 ATF_TC_BODY(aio_fsync_dsync_test, tc)
1514 aio_fsync_test(O_DSYNC);
1518 * We shouldn't be able to DoS the system by setting iov_len to an insane
1521 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iov_len);
1522 ATF_TC_BODY(aio_writev_dos_iov_len, tc)
1525 const struct aiocb *const iocbs[] = {&aio};
1526 const char *wbuf = "Hello, world!";
1527 struct iovec iov[1];
1531 ATF_REQUIRE_KERNEL_MODULE("aio");
1532 ATF_REQUIRE_UNSAFE_AIO();
1534 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1535 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1538 iov[0].iov_base = __DECONST(void*, wbuf);
1539 iov[0].iov_len = 1 << 30;
1540 bzero(&aio, sizeof(aio));
1541 aio.aio_fildes = fd;
1546 r = aio_writev(&aio);
1547 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1548 ATF_REQUIRE_EQ(0, aio_suspend(iocbs, 1, NULL));
1549 r = aio_return(&aio);
1550 ATF_CHECK_EQ_MSG(-1, r, "aio_return returned %zd", r);
1551 ATF_CHECK_MSG(errno == EFAULT || errno == EINVAL,
1552 "aio_writev: %s", strerror(errno));
1558 * We shouldn't be able to DoS the system by setting aio_iovcnt to an insane
1561 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iovcnt);
1562 ATF_TC_BODY(aio_writev_dos_iovcnt, tc)
1565 const char *wbuf = "Hello, world!";
1566 struct iovec iov[1];
1570 ATF_REQUIRE_KERNEL_MODULE("aio");
1571 ATF_REQUIRE_UNSAFE_AIO();
1573 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1574 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1577 iov[0].iov_base = __DECONST(void*, wbuf);
1578 iov[0].iov_len = len;
1579 bzero(&aio, sizeof(aio));
1580 aio.aio_fildes = fd;
1583 aio.aio_iovcnt = 1 << 30;
1585 ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1586 ATF_CHECK_EQ(EINVAL, errno);
1591 ATF_TC_WITH_CLEANUP(aio_writev_efault);
1592 ATF_TC_HEAD(aio_writev_efault, tc)
1594 atf_tc_set_md_var(tc, "descr",
1595 "Vectored AIO should gracefully handle invalid addresses");
1596 atf_tc_set_md_var(tc, "require.user", "root");
1598 ATF_TC_BODY(aio_writev_efault, tc)
1603 struct iovec iov[2];
1607 ATF_REQUIRE_KERNEL_MODULE("aio");
1608 ATF_REQUIRE_UNSAFE_AIO();
1610 fd = aio_md_setup();
1614 buffer = malloc(buflen);
1615 aio_fill_buffer(buffer, buflen, seed);
1616 iov[0].iov_base = buffer;
1617 iov[0].iov_len = buflen;
1618 iov[1].iov_base = (void*)-1; /* Invalid! */
1619 iov[1].iov_len = buflen;
1620 bzero(&aio, sizeof(aio));
1621 aio.aio_fildes = fd;
1624 aio.aio_iovcnt = nitems(iov);
1626 ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1627 ATF_CHECK_EQ(EFAULT, errno);
1631 ATF_TC_CLEANUP(aio_writev_efault, tc)
1636 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_poll);
1637 ATF_TC_BODY(aio_writev_empty_file_poll, tc)
1642 ATF_REQUIRE_KERNEL_MODULE("aio");
1643 ATF_REQUIRE_UNSAFE_AIO();
1645 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1646 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1648 bzero(&aio, sizeof(aio));
1649 aio.aio_fildes = fd;
1653 ATF_REQUIRE_EQ(0, aio_writev(&aio));
1654 ATF_REQUIRE_EQ(0, suspend(&aio));
1659 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_signal);
1660 ATF_TC_BODY(aio_writev_empty_file_signal, tc)
1665 ATF_REQUIRE_KERNEL_MODULE("aio");
1666 ATF_REQUIRE_UNSAFE_AIO();
1668 fd = open("testfile", O_RDWR | O_CREAT, 0600);
1669 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1671 bzero(&aio, sizeof(aio));
1672 aio.aio_fildes = fd;
1675 aio.aio_sigevent = *setup_signal();
1677 ATF_REQUIRE_EQ(0, aio_writev(&aio));
1678 ATF_REQUIRE_EQ(0, poll_signaled(&aio));
1683 // aio_writev and aio_readv should still work even if the iovcnt is greater
1684 // than the number of buffered AIO operations permitted per process.
1685 ATF_TC_WITH_CLEANUP(vectored_big_iovcnt);
1686 ATF_TC_HEAD(vectored_big_iovcnt, tc)
1688 atf_tc_set_md_var(tc, "descr",
1689 "Vectored AIO should still work even if the iovcnt is greater than "
1690 "the number of buffered AIO operations permitted by the process");
1691 atf_tc_set_md_var(tc, "require.user", "root");
1693 ATF_TC_BODY(vectored_big_iovcnt, tc)
1697 ssize_t len, buflen;
1699 const char *oid = "vfs.aio.max_buf_aio";
1703 ssize_t sysctl_len = sizeof(max_buf_aio);
1705 ATF_REQUIRE_KERNEL_MODULE("aio");
1706 ATF_REQUIRE_UNSAFE_AIO();
1708 if (sysctlbyname(oid, &max_buf_aio, &sysctl_len, NULL, 0) == -1)
1709 atf_libc_error(errno, "Failed to read %s", oid);
1712 buflen = 512 * (max_buf_aio + 1);
1713 buffer = malloc(buflen);
1714 aio_fill_buffer(buffer, buflen, seed);
1715 iov = calloc(max_buf_aio + 1, sizeof(struct iovec));
1717 fd = aio_md_setup();
1719 bzero(&aio, sizeof(aio));
1720 aio.aio_fildes = fd;
1722 for (i = 0; i < max_buf_aio + 1; i++) {
1723 iov[i].iov_base = &buffer[i * 512];
1724 iov[i].iov_len = 512;
1727 aio.aio_iovcnt = max_buf_aio + 1;
1729 if (aio_writev(&aio) < 0)
1730 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1734 atf_tc_fail("aio failed: %s", strerror(errno));
1737 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
1739 bzero(&aio, sizeof(aio));
1740 aio.aio_fildes = fd;
1743 aio.aio_iovcnt = max_buf_aio + 1;
1745 if (aio_readv(&aio) < 0)
1746 atf_tc_fail("aio_readv failed: %s", strerror(errno));
1750 atf_tc_fail("aio failed: %s", strerror(errno));
1753 atf_tc_fail("aio short read (%jd)", (intmax_t)len);
1755 if (aio_test_buffer(buffer, buflen, seed) == 0)
1756 atf_tc_fail("buffer mismatched");
1760 ATF_TC_CLEANUP(vectored_big_iovcnt, tc)
1765 ATF_TC_WITHOUT_HEAD(vectored_file_poll);
1766 ATF_TC_BODY(vectored_file_poll, tc)
1768 aio_file_test(poll, NULL, true);
1771 ATF_TC_WITHOUT_HEAD(vectored_thread);
1772 ATF_TC_BODY(vectored_thread, tc)
1774 aio_file_test(poll_signaled, setup_thread(), true);
1777 ATF_TC_WITH_CLEANUP(vectored_md_poll);
1778 ATF_TC_HEAD(vectored_md_poll, tc)
1780 atf_tc_set_md_var(tc, "require.user", "root");
1782 ATF_TC_BODY(vectored_md_poll, tc)
1784 aio_md_test(poll, NULL, true);
1786 ATF_TC_CLEANUP(vectored_md_poll, tc)
1791 ATF_TC_WITHOUT_HEAD(vectored_socket_poll);
1792 ATF_TC_BODY(vectored_socket_poll, tc)
1794 aio_unix_socketpair_test(poll, NULL, true);
1797 // aio_writev and aio_readv should still work even if the iov contains elements
1798 // that aren't a multiple of the device's sector size, and even if the total
1799 // amount if I/O _is_ a multiple of the device's sector size.
1800 ATF_TC_WITH_CLEANUP(vectored_unaligned);
1801 ATF_TC_HEAD(vectored_unaligned, tc)
1803 atf_tc_set_md_var(tc, "descr",
1804 "Vectored AIO should still work even if the iov contains elements "
1805 "that aren't a multiple of the sector size.");
1806 atf_tc_set_md_var(tc, "require.user", "root");
1808 ATF_TC_BODY(vectored_unaligned, tc)
1810 struct aio_context ac;
1812 struct iovec iov[3];
1813 ssize_t len, total_len;
1816 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false))
1817 atf_tc_skip("https://bugs.freebsd.org/258766");
1819 ATF_REQUIRE_KERNEL_MODULE("aio");
1820 ATF_REQUIRE_UNSAFE_AIO();
1823 * Use a zvol with volmode=dev, so it will allow .d_write with
1824 * unaligned uio. geom devices use physio, which doesn't allow that.
1826 fd = aio_zvol_setup();
1827 aio_context_init(&ac, fd, fd, FILE_LEN);
1829 /* Break the buffer into 3 parts:
1830 * * A 4kB part, aligned to 4kB
1831 * * Two other parts that add up to 4kB:
1835 iov[0].iov_base = ac.ac_buffer;
1836 iov[0].iov_len = 4096;
1837 iov[1].iov_base = (void*)((uintptr_t)iov[0].iov_base + iov[0].iov_len);
1838 iov[1].iov_len = 256;
1839 iov[2].iov_base = (void*)((uintptr_t)iov[1].iov_base + iov[1].iov_len);
1840 iov[2].iov_len = 4096 - iov[1].iov_len;
1841 total_len = iov[0].iov_len + iov[1].iov_len + iov[2].iov_len;
1842 bzero(&aio, sizeof(aio));
1843 aio.aio_fildes = ac.ac_write_fd;
1848 if (aio_writev(&aio) < 0)
1849 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1853 atf_tc_fail("aio failed: %s", strerror(errno));
1855 if (len != total_len)
1856 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
1858 bzero(&aio, sizeof(aio));
1859 aio.aio_fildes = ac.ac_read_fd;
1864 if (aio_readv(&aio) < 0)
1865 atf_tc_fail("aio_readv failed: %s", strerror(errno));
1868 ATF_REQUIRE_MSG(aio_test_buffer(ac.ac_buffer, total_len,
1869 ac.ac_seed) != 0, "aio_test_buffer: internal error");
1873 ATF_TC_CLEANUP(vectored_unaligned, tc)
1879 aio_zvol_test(completion comp, struct sigevent *sev, bool vectored)
1881 struct aio_context ac;
1884 fd = aio_zvol_setup();
1885 aio_context_init(&ac, fd, fd, MD_LEN);
1887 aio_writev_test(&ac, comp, sev);
1888 aio_readv_test(&ac, comp, sev);
1890 aio_write_test(&ac, comp, sev);
1891 aio_read_test(&ac, comp, sev);
1898 * Note that unlike md, the zvol is not a geom device, does not allow unmapped
1899 * buffers, and does not use physio.
1901 ATF_TC_WITH_CLEANUP(vectored_zvol_poll);
1902 ATF_TC_HEAD(vectored_zvol_poll, tc)
1904 atf_tc_set_md_var(tc, "require.user", "root");
1906 ATF_TC_BODY(vectored_zvol_poll, tc)
1908 if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false))
1909 atf_tc_skip("https://bugs.freebsd.org/258766");
1910 aio_zvol_test(poll, NULL, true);
1912 ATF_TC_CLEANUP(vectored_zvol_poll, tc)
1920 ATF_TP_ADD_TC(tp, file_poll);
1921 ATF_TP_ADD_TC(tp, file_signal);
1922 ATF_TP_ADD_TC(tp, file_suspend);
1923 ATF_TP_ADD_TC(tp, file_thread);
1924 ATF_TP_ADD_TC(tp, file_waitcomplete);
1925 ATF_TP_ADD_TC(tp, fifo_poll);
1926 ATF_TP_ADD_TC(tp, fifo_signal);
1927 ATF_TP_ADD_TC(tp, fifo_suspend);
1928 ATF_TP_ADD_TC(tp, fifo_thread);
1929 ATF_TP_ADD_TC(tp, fifo_waitcomplete);
1930 ATF_TP_ADD_TC(tp, socket_poll);
1931 ATF_TP_ADD_TC(tp, socket_signal);
1932 ATF_TP_ADD_TC(tp, socket_suspend);
1933 ATF_TP_ADD_TC(tp, socket_thread);
1934 ATF_TP_ADD_TC(tp, socket_waitcomplete);
1935 ATF_TP_ADD_TC(tp, pty_poll);
1936 ATF_TP_ADD_TC(tp, pty_signal);
1937 ATF_TP_ADD_TC(tp, pty_suspend);
1938 ATF_TP_ADD_TC(tp, pty_thread);
1939 ATF_TP_ADD_TC(tp, pty_waitcomplete);
1940 ATF_TP_ADD_TC(tp, pipe_poll);
1941 ATF_TP_ADD_TC(tp, pipe_signal);
1942 ATF_TP_ADD_TC(tp, pipe_suspend);
1943 ATF_TP_ADD_TC(tp, pipe_thread);
1944 ATF_TP_ADD_TC(tp, pipe_waitcomplete);
1945 ATF_TP_ADD_TC(tp, md_poll);
1946 ATF_TP_ADD_TC(tp, md_signal);
1947 ATF_TP_ADD_TC(tp, md_suspend);
1948 ATF_TP_ADD_TC(tp, md_thread);
1949 ATF_TP_ADD_TC(tp, md_waitcomplete);
1950 ATF_TP_ADD_TC(tp, aio_fsync_errors);
1951 ATF_TP_ADD_TC(tp, aio_fsync_sync_test);
1952 ATF_TP_ADD_TC(tp, aio_fsync_dsync_test);
1953 ATF_TP_ADD_TC(tp, aio_large_read_test);
1954 ATF_TP_ADD_TC(tp, aio_socket_two_reads);
1955 ATF_TP_ADD_TC(tp, aio_socket_blocking_short_write);
1956 ATF_TP_ADD_TC(tp, aio_socket_blocking_short_write_vectored);
1957 ATF_TP_ADD_TC(tp, aio_socket_listen_fail);
1958 ATF_TP_ADD_TC(tp, aio_socket_listen_pending);
1959 ATF_TP_ADD_TC(tp, aio_socket_short_write_cancel);
1960 ATF_TP_ADD_TC(tp, aio_socket_shutdown);
1961 ATF_TP_ADD_TC(tp, aio_writev_dos_iov_len);
1962 ATF_TP_ADD_TC(tp, aio_writev_dos_iovcnt);
1963 ATF_TP_ADD_TC(tp, aio_writev_efault);
1964 ATF_TP_ADD_TC(tp, aio_writev_empty_file_poll);
1965 ATF_TP_ADD_TC(tp, aio_writev_empty_file_signal);
1966 ATF_TP_ADD_TC(tp, vectored_big_iovcnt);
1967 ATF_TP_ADD_TC(tp, vectored_file_poll);
1968 ATF_TP_ADD_TC(tp, vectored_md_poll);
1969 ATF_TP_ADD_TC(tp, vectored_zvol_poll);
1970 ATF_TP_ADD_TC(tp, vectored_unaligned);
1971 ATF_TP_ADD_TC(tp, vectored_socket_poll);
1972 ATF_TP_ADD_TC(tp, vectored_thread);
1974 return (atf_no_error());