tests/sys/aio/aio_test.c

   1 /*-
   2  * Copyright (c) 2004 Robert N. M. Watson
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   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.
  13  *
  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
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  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
  37  * types.
  38  */
  39
  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>
  46 #include <sys/stat.h>
  47 #include <sys/un.h>
  48
  49 #include <aio.h>
  50 #include <err.h>
  51 #include <errno.h>
  52 #include <fcntl.h>
  53 #include <libutil.h>
  54 #include <limits.h>
  55 #include <semaphore.h>
  56 #include <signal.h>
  57 #include <stdint.h>
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <string.h>
  61 #include <termios.h>
  62 #include <unistd.h>
  63
  64 #include <atf-c.h>
  65
  66 #include "freebsd_test_suite/macros.h"
  67 #include "local.h"
  68
  69 /*
  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).
  74  */
  75 #define GLOBAL_MAX      16384
  76
  77 #define BUFFER_MAX      GLOBAL_MAX
  78
  79 /*
  80  * A completion function will block until the aio has completed, then return
  81  * the result of the aio.  errno will be set appropriately.
  82  */
  83 typedef ssize_t (*completion)(struct aiocb*);
  84
  85 struct aio_context {
  86         int              ac_read_fd, ac_write_fd;
  87         long             ac_seed;
  88         char             ac_buffer[GLOBAL_MAX];
  89         int              ac_buflen;
  90         int              ac_seconds;
  91 };
  92
  93 static sem_t            completions;
  94
  95 /*
  96  * Fill a buffer given a seed that can be fed into srandom() to initialize
  97  * the PRNG in a repeatable manner.
  98  */
  99 static void
 100 aio_fill_buffer(char *buffer, int len, long seed)
 101 {
 102         char ch;
 103         int i;
 104
 105         srandom(seed);
 106         for (i = 0; i < len; i++) {
 107                 ch = random() & 0xff;
 108                 buffer[i] = ch;
 109         }
 110 }
 111
 112 /*
 113  * Test that a buffer matches a given seed.  See aio_fill_buffer().  Return
 114  * (1) on a match, (0) on a mismatch.
 115  */
 116 static int
 117 aio_test_buffer(char *buffer, int len, long seed)
 118 {
 119         char ch;
 120         int i;
 121
 122         srandom(seed);
 123         for (i = 0; i < len; i++) {
 124                 ch = random() & 0xff;
 125                 if (buffer[i] != ch)
 126                         return (0);
 127         }
 128         return (1);
 129 }
 130
 131 /*
 132  * Initialize a testing context given the file descriptors provided by the
 133  * test setup.
 134  */
 135 static void
 136 aio_context_init(struct aio_context *ac, int read_fd,
 137     int write_fd, int buflen)
 138 {
 139
 140         ATF_REQUIRE_MSG(buflen <= BUFFER_MAX,
 141             "aio_context_init: buffer too large (%d > %d)",
 142             buflen, BUFFER_MAX);
 143         bzero(ac, sizeof(*ac));
 144         ac->ac_read_fd = read_fd;
 145         ac->ac_write_fd = write_fd;
 146         ac->ac_buflen = buflen;
 147         srandomdev();
 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");
 152 }
 153
 154 static ssize_t
 155 poll(struct aiocb *aio)
 156 {
 157         int error;
 158
 159         while ((error = aio_error(aio)) == EINPROGRESS)
 160                 usleep(25000);
 161         if (error)
 162                 return (error);
 163         else
 164                 return (aio_return(aio));
 165 }
 166
 167 static void
 168 sigusr1_handler(int sig __unused)
 169 {
 170         ATF_REQUIRE_EQ(0, sem_post(&completions));
 171 }
 172
 173 static void
 174 thr_handler(union sigval sv __unused)
 175 {
 176         ATF_REQUIRE_EQ(0, sem_post(&completions));
 177 }
 178
 179 static ssize_t
 180 poll_signaled(struct aiocb *aio)
 181 {
 182         int error;
 183
 184         ATF_REQUIRE_EQ(0, sem_wait(&completions));
 185         error = aio_error(aio);
 186         switch (error) {
 187                 case EINPROGRESS:
 188                         errno = EINTR;
 189                         return (-1);
 190                 case 0:
 191                         return (aio_return(aio));
 192                 default:
 193                         return (error);
 194         }
 195 }
 196
 197 /*
 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
 200  * separate process
 201  */
 202 static struct sigevent*
 203 setup_signal(void)
 204 {
 205         static struct sigevent sev;
 206
 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));
 211         return (&sev);
 212 }
 213
 214 /*
 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
 217  * separate process
 218  */
 219 static struct sigevent*
 220 setup_thread(void)
 221 {
 222         static struct sigevent sev;
 223
 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;
 228         return (&sev);
 229 }
 230
 231 static ssize_t
 232 suspend(struct aiocb *aio)
 233 {
 234         const struct aiocb *const iocbs[] = {aio};
 235         int error;
 236
 237         error = aio_suspend(iocbs, 1, NULL);
 238         if (error == 0)
 239                 return (aio_return(aio));
 240         else
 241                 return (error);
 242 }
 243
 244 static ssize_t
 245 waitcomplete(struct aiocb *aio)
 246 {
 247         struct aiocb *aiop;
 248         ssize_t ret;
 249
 250         ret = aio_waitcomplete(&aiop, NULL);
 251         ATF_REQUIRE_EQ(aio, aiop);
 252         return (ret);
 253 }
 254
 255 /*
 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.
 258  */
 259 static struct sigevent*
 260 setup_kqueue(void)
 261 {
 262         static struct sigevent sev;
 263         static int kq;
 264
 265         kq = kqueue();
 266         ATF_REQUIRE(kq >= 0);
 267
 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;
 272
 273         return (&sev);
 274 }
 275
 276 static ssize_t
 277 poll_kqueue(struct aiocb *aio)
 278 {
 279         int kq, nevents;
 280         struct kevent events[1];
 281
 282         kq = aio->aio_sigevent.sigev_notify_kqueue;
 283
 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);
 292
 293         return (aio_return(aio));
 294 }
 295
 296 /*
 297  * Perform a simple write test of our initialized data buffer to the provided
 298  * file descriptor.
 299  */
 300 static void
 301 aio_write_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 302 {
 303         struct aiocb aio;
 304         ssize_t len;
 305
 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;
 310         aio.aio_offset = 0;
 311         if (sev)
 312                 aio.aio_sigevent = *sev;
 313
 314         if (aio_write(&aio) < 0)
 315                 atf_tc_fail("aio_write failed: %s", strerror(errno));
 316
 317         len = comp(&aio);
 318         if (len < 0)
 319                 atf_tc_fail("aio failed: %s", strerror(errno));
 320
 321         if (len != ac->ac_buflen)
 322                 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
 323 }
 324
 325 /*
 326  * Perform a vectored I/O test of our initialized data buffer to the provided
 327  * file descriptor.
 328  *
 329  * To vectorize the linear buffer, chop it up into two pieces of dissimilar
 330  * size, and swap their offsets.
 331  */
 332 static void
 333 aio_writev_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 334 {
 335         struct aiocb aio;
 336         struct iovec iov[2];
 337         size_t len0, len1;
 338         ssize_t len;
 339
 340         bzero(&aio, sizeof(aio));
 341
 342         aio.aio_fildes = ac->ac_write_fd;
 343         aio.aio_offset = 0;
 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;
 350         aio.aio_iov = iov;
 351         aio.aio_iovcnt = 2;
 352         if (sev)
 353                 aio.aio_sigevent = *sev;
 354
 355         if (aio_writev(&aio) < 0)
 356                 atf_tc_fail("aio_writev failed: %s", strerror(errno));
 357
 358         len = comp(&aio);
 359         if (len < 0)
 360                 atf_tc_fail("aio failed: %s", strerror(errno));
 361
 362         if (len != ac->ac_buflen)
 363                 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
 364 }
 365
 366 /*
 367  * Perform a simple read test of our initialized data buffer from the
 368  * provided file descriptor.
 369  */
 370 static void
 371 aio_read_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 372 {
 373         struct aiocb aio;
 374         ssize_t len;
 375
 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;
 381         aio.aio_offset = 0;
 382         if (sev)
 383                 aio.aio_sigevent = *sev;
 384
 385         if (aio_read(&aio) < 0)
 386                 atf_tc_fail("aio_read failed: %s", strerror(errno));
 387
 388         len = comp(&aio);
 389         if (len < 0)
 390                 atf_tc_fail("aio failed: %s", strerror(errno));
 391
 392         ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
 393             "aio short read (%jd)", (intmax_t)len);
 394
 395         if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
 396                 atf_tc_fail("buffer mismatched");
 397 }
 398
 399 static void
 400 aio_readv_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 401 {
 402         struct aiocb aio;
 403         struct iovec iov[2];
 404         size_t len0, len1;
 405         ssize_t len;
 406
 407         bzero(ac->ac_buffer, ac->ac_buflen);
 408         bzero(&aio, sizeof(aio));
 409         aio.aio_fildes = ac->ac_read_fd;
 410         aio.aio_offset = 0;
 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;
 417         aio.aio_iov = iov;
 418         aio.aio_iovcnt = 2;
 419         if (sev)
 420                 aio.aio_sigevent = *sev;
 421
 422         if (aio_readv(&aio) < 0)
 423                 atf_tc_fail("aio_read failed: %s", strerror(errno));
 424
 425         len = comp(&aio);
 426         if (len < 0)
 427                 atf_tc_fail("aio failed: %s", strerror(errno));
 428
 429         ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
 430             "aio short read (%jd)", (intmax_t)len);
 431
 432         if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
 433                 atf_tc_fail("buffer mismatched");
 434 }
 435
 436 /*
 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.
 440  */
 441
 442 /*
 443  * Test with a classic file.  Assumes we can create a moderate size temporary
 444  * file.
 445  */
 446 #define FILE_LEN        GLOBAL_MAX
 447 #define FILE_PATHNAME   "testfile"
 448
 449 static void
 450 aio_file_test(completion comp, struct sigevent *sev, bool vectored)
 451 {
 452         struct aio_context ac;
 453         int fd;
 454
 455         ATF_REQUIRE_KERNEL_MODULE("aio");
 456         ATF_REQUIRE_UNSAFE_AIO();
 457
 458         fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
 459         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
 460
 461         aio_context_init(&ac, fd, fd, FILE_LEN);
 462         if (vectored) {
 463                 aio_writev_test(&ac, comp, sev);
 464                 aio_readv_test(&ac, comp, sev);
 465         } else {
 466                 aio_write_test(&ac, comp, sev);
 467                 aio_read_test(&ac, comp, sev);
 468         }
 469         close(fd);
 470 }
 471
 472 ATF_TC_WITHOUT_HEAD(file_kq);
 473 ATF_TC_BODY(file_kq, tc)
 474 {
 475         aio_file_test(poll_kqueue, setup_kqueue(), false);
 476 }
 477
 478 ATF_TC_WITHOUT_HEAD(file_poll);
 479 ATF_TC_BODY(file_poll, tc)
 480 {
 481         aio_file_test(poll, NULL, false);
 482 }
 483
 484 ATF_TC_WITHOUT_HEAD(file_signal);
 485 ATF_TC_BODY(file_signal, tc)
 486 {
 487         aio_file_test(poll_signaled, setup_signal(), false);
 488 }
 489
 490 ATF_TC_WITHOUT_HEAD(file_suspend);
 491 ATF_TC_BODY(file_suspend, tc)
 492 {
 493         aio_file_test(suspend, NULL, false);
 494 }
 495
 496 ATF_TC_WITHOUT_HEAD(file_thread);
 497 ATF_TC_BODY(file_thread, tc)
 498 {
 499         aio_file_test(poll_signaled, setup_thread(), false);
 500 }
 501
 502 ATF_TC_WITHOUT_HEAD(file_waitcomplete);
 503 ATF_TC_BODY(file_waitcomplete, tc)
 504 {
 505         aio_file_test(waitcomplete, NULL, false);
 506 }
 507
 508 #define FIFO_LEN        256
 509 #define FIFO_PATHNAME   "testfifo"
 510
 511 static void
 512 aio_fifo_test(completion comp, struct sigevent *sev)
 513 {
 514         int error, read_fd = -1, write_fd = -1;
 515         struct aio_context ac;
 516
 517         ATF_REQUIRE_KERNEL_MODULE("aio");
 518         ATF_REQUIRE_UNSAFE_AIO();
 519
 520         ATF_REQUIRE_MSG(mkfifo(FIFO_PATHNAME, 0600) != -1,
 521             "mkfifo failed: %s", strerror(errno));
 522
 523         read_fd = open(FIFO_PATHNAME, O_RDONLY | O_NONBLOCK);
 524         if (read_fd == -1) {
 525                 error = errno;
 526                 errno = error;
 527                 atf_tc_fail("read_fd open failed: %s",
 528                     strerror(errno));
 529         }
 530
 531         write_fd = open(FIFO_PATHNAME, O_WRONLY);
 532         if (write_fd == -1) {
 533                 error = errno;
 534                 errno = error;
 535                 atf_tc_fail("write_fd open failed: %s",
 536                     strerror(errno));
 537         }
 538
 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);
 542
 543         close(read_fd);
 544         close(write_fd);
 545 }
 546
 547 ATF_TC_WITHOUT_HEAD(fifo_kq);
 548 ATF_TC_BODY(fifo_kq, tc)
 549 {
 550         aio_fifo_test(poll_kqueue, setup_kqueue());
 551 }
 552
 553 ATF_TC_WITHOUT_HEAD(fifo_poll);
 554 ATF_TC_BODY(fifo_poll, tc)
 555 {
 556         aio_fifo_test(poll, NULL);
 557 }
 558
 559 ATF_TC_WITHOUT_HEAD(fifo_signal);
 560 ATF_TC_BODY(fifo_signal, tc)
 561 {
 562         aio_fifo_test(poll_signaled, setup_signal());
 563 }
 564
 565 ATF_TC_WITHOUT_HEAD(fifo_suspend);
 566 ATF_TC_BODY(fifo_suspend, tc)
 567 {
 568         aio_fifo_test(suspend, NULL);
 569 }
 570
 571 ATF_TC_WITHOUT_HEAD(fifo_thread);
 572 ATF_TC_BODY(fifo_thread, tc)
 573 {
 574         aio_fifo_test(poll_signaled, setup_thread());
 575 }
 576
 577 ATF_TC_WITHOUT_HEAD(fifo_waitcomplete);
 578 ATF_TC_BODY(fifo_waitcomplete, tc)
 579 {
 580         aio_fifo_test(waitcomplete, NULL);
 581 }
 582
 583 #define UNIX_SOCKETPAIR_LEN     256
 584 static void
 585 aio_unix_socketpair_test(completion comp, struct sigevent *sev, bool vectored)
 586 {
 587         struct aio_context ac;
 588         struct rusage ru_before, ru_after;
 589         int sockets[2];
 590
 591         ATF_REQUIRE_KERNEL_MODULE("aio");
 592
 593         ATF_REQUIRE_MSG(socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) != -1,
 594             "socketpair failed: %s", strerror(errno));
 595
 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));
 599         if (vectored) {
 600                 aio_writev_test(&ac, comp, sev);
 601                 aio_readv_test(&ac, comp, sev);
 602         } else {
 603                 aio_write_test(&ac, comp, sev);
 604                 aio_read_test(&ac, comp, sev);
 605         }
 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);
 610
 611         close(sockets[0]);
 612         close(sockets[1]);
 613 }
 614
 615 ATF_TC_WITHOUT_HEAD(socket_kq);
 616 ATF_TC_BODY(socket_kq, tc)
 617 {
 618         aio_unix_socketpair_test(poll_kqueue, setup_kqueue(), false);
 619 }
 620
 621 ATF_TC_WITHOUT_HEAD(socket_poll);
 622 ATF_TC_BODY(socket_poll, tc)
 623 {
 624         aio_unix_socketpair_test(poll, NULL, false);
 625 }
 626
 627 ATF_TC_WITHOUT_HEAD(socket_signal);
 628 ATF_TC_BODY(socket_signal, tc)
 629 {
 630         aio_unix_socketpair_test(poll_signaled, setup_signal(), false);
 631 }
 632
 633 ATF_TC_WITHOUT_HEAD(socket_suspend);
 634 ATF_TC_BODY(socket_suspend, tc)
 635 {
 636         aio_unix_socketpair_test(suspend, NULL, false);
 637 }
 638
 639 ATF_TC_WITHOUT_HEAD(socket_thread);
 640 ATF_TC_BODY(socket_thread, tc)
 641 {
 642         aio_unix_socketpair_test(poll_signaled, setup_thread(), false);
 643 }
 644
 645 ATF_TC_WITHOUT_HEAD(socket_waitcomplete);
 646 ATF_TC_BODY(socket_waitcomplete, tc)
 647 {
 648         aio_unix_socketpair_test(waitcomplete, NULL, false);
 649 }
 650
 651 struct aio_pty_arg {
 652         int     apa_read_fd;
 653         int     apa_write_fd;
 654 };
 655
 656 #define PTY_LEN         256
 657 static void
 658 aio_pty_test(completion comp, struct sigevent *sev)
 659 {
 660         struct aio_context ac;
 661         int read_fd, write_fd;
 662         struct termios ts;
 663         int error;
 664
 665         ATF_REQUIRE_KERNEL_MODULE("aio");
 666         ATF_REQUIRE_UNSAFE_AIO();
 667
 668         ATF_REQUIRE_MSG(openpty(&read_fd, &write_fd, NULL, NULL, NULL) == 0,
 669             "openpty failed: %s", strerror(errno));
 670
 671
 672         if (tcgetattr(write_fd, &ts) < 0) {
 673                 error = errno;
 674                 errno = error;
 675                 atf_tc_fail("tcgetattr failed: %s", strerror(errno));
 676         }
 677         cfmakeraw(&ts);
 678         if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
 679                 error = errno;
 680                 errno = error;
 681                 atf_tc_fail("tcsetattr failed: %s", strerror(errno));
 682         }
 683         aio_context_init(&ac, read_fd, write_fd, PTY_LEN);
 684
 685         aio_write_test(&ac, comp, sev);
 686         aio_read_test(&ac, comp, sev);
 687
 688         close(read_fd);
 689         close(write_fd);
 690 }
 691
 692 ATF_TC_WITHOUT_HEAD(pty_kq);
 693 ATF_TC_BODY(pty_kq, tc)
 694 {
 695         aio_pty_test(poll_kqueue, setup_kqueue());
 696 }
 697
 698 ATF_TC_WITHOUT_HEAD(pty_poll);
 699 ATF_TC_BODY(pty_poll, tc)
 700 {
 701         aio_pty_test(poll, NULL);
 702 }
 703
 704 ATF_TC_WITHOUT_HEAD(pty_signal);
 705 ATF_TC_BODY(pty_signal, tc)
 706 {
 707         aio_pty_test(poll_signaled, setup_signal());
 708 }
 709
 710 ATF_TC_WITHOUT_HEAD(pty_suspend);
 711 ATF_TC_BODY(pty_suspend, tc)
 712 {
 713         aio_pty_test(suspend, NULL);
 714 }
 715
 716 ATF_TC_WITHOUT_HEAD(pty_thread);
 717 ATF_TC_BODY(pty_thread, tc)
 718 {
 719         aio_pty_test(poll_signaled, setup_thread());
 720 }
 721
 722 ATF_TC_WITHOUT_HEAD(pty_waitcomplete);
 723 ATF_TC_BODY(pty_waitcomplete, tc)
 724 {
 725         aio_pty_test(waitcomplete, NULL);
 726 }
 727
 728 #define PIPE_LEN        256
 729 static void
 730 aio_pipe_test(completion comp, struct sigevent *sev)
 731 {
 732         struct aio_context ac;
 733         int pipes[2];
 734
 735         ATF_REQUIRE_KERNEL_MODULE("aio");
 736         ATF_REQUIRE_UNSAFE_AIO();
 737
 738         ATF_REQUIRE_MSG(pipe(pipes) != -1,
 739             "pipe failed: %s", strerror(errno));
 740
 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);
 744
 745         close(pipes[0]);
 746         close(pipes[1]);
 747 }
 748
 749 ATF_TC_WITHOUT_HEAD(pipe_kq);
 750 ATF_TC_BODY(pipe_kq, tc)
 751 {
 752         aio_pipe_test(poll_kqueue, setup_kqueue());
 753 }
 754
 755 ATF_TC_WITHOUT_HEAD(pipe_poll);
 756 ATF_TC_BODY(pipe_poll, tc)
 757 {
 758         aio_pipe_test(poll, NULL);
 759 }
 760
 761 ATF_TC_WITHOUT_HEAD(pipe_signal);
 762 ATF_TC_BODY(pipe_signal, tc)
 763 {
 764         aio_pipe_test(poll_signaled, setup_signal());
 765 }
 766
 767 ATF_TC_WITHOUT_HEAD(pipe_suspend);
 768 ATF_TC_BODY(pipe_suspend, tc)
 769 {
 770         aio_pipe_test(suspend, NULL);
 771 }
 772
 773 ATF_TC_WITHOUT_HEAD(pipe_thread);
 774 ATF_TC_BODY(pipe_thread, tc)
 775 {
 776         aio_pipe_test(poll_signaled, setup_thread());
 777 }
 778
 779 ATF_TC_WITHOUT_HEAD(pipe_waitcomplete);
 780 ATF_TC_BODY(pipe_waitcomplete, tc)
 781 {
 782         aio_pipe_test(waitcomplete, NULL);
 783 }
 784
 785 #define MD_LEN          GLOBAL_MAX
 786 #define MDUNIT_LINK     "mdunit_link"
 787
 788 static int
 789 aio_md_setup(void)
 790 {
 791         int error, fd, mdctl_fd, unit;
 792         char pathname[PATH_MAX];
 793         struct md_ioctl mdio;
 794         char buf[80];
 795
 796         ATF_REQUIRE_KERNEL_MODULE("aio");
 797
 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));
 801
 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));
 809         mdio.md_label = buf;
 810
 811         if (ioctl(mdctl_fd, MDIOCATTACH, &mdio) < 0) {
 812                 error = errno;
 813                 errno = error;
 814                 atf_tc_fail("ioctl MDIOCATTACH failed: %s", strerror(errno));
 815         }
 816         close(mdctl_fd);
 817
 818         /* Store the md unit number in a symlink for future cleanup */
 819         unit = mdio.md_unit;
 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));
 826
 827         return (fd);
 828 }
 829
 830 static void
 831 aio_md_cleanup(void)
 832 {
 833         struct md_ioctl mdio;
 834         int mdctl_fd, n, unit;
 835         char buf[80];
 836
 837         mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
 838         if (mdctl_fd < 0) {
 839                 fprintf(stderr, "opening /dev/%s failed: %s\n", MDCTL_NAME,
 840                     strerror(errno));
 841                 return;
 842         }
 843         n = readlink(MDUNIT_LINK, buf, sizeof(buf) - 1);
 844         if (n > 0) {
 845                 buf[n] = '\0';
 846                 if (sscanf(buf, "%d", &unit) == 1 && unit >= 0) {
 847                         bzero(&mdio, sizeof(mdio));
 848                         mdio.md_version = MDIOVERSION;
 849                         mdio.md_unit = unit;
 850                         if (ioctl(mdctl_fd, MDIOCDETACH, &mdio) == -1) {
 851                                 fprintf(stderr,
 852                                     "ioctl MDIOCDETACH unit %d failed: %s\n",
 853                                     unit, strerror(errno));
 854                         }
 855                 }
 856         }
 857
 858         close(mdctl_fd);
 859 }
 860
 861 static void
 862 aio_md_test(completion comp, struct sigevent *sev, bool vectored)
 863 {
 864         struct aio_context ac;
 865         int fd;
 866
 867         fd = aio_md_setup();
 868         aio_context_init(&ac, fd, fd, MD_LEN);
 869         if (vectored) {
 870                 aio_writev_test(&ac, comp, sev);
 871                 aio_readv_test(&ac, comp, sev);
 872         } else {
 873                 aio_write_test(&ac, comp, sev);
 874                 aio_read_test(&ac, comp, sev);
 875         }
 876
 877         close(fd);
 878 }
 879
 880 ATF_TC_WITH_CLEANUP(md_kq);
 881 ATF_TC_HEAD(md_kq, tc)
 882 {
 883
 884         atf_tc_set_md_var(tc, "require.user", "root");
 885 }
 886 ATF_TC_BODY(md_kq, tc)
 887 {
 888         aio_md_test(poll_kqueue, setup_kqueue(), false);
 889 }
 890 ATF_TC_CLEANUP(md_kq, tc)
 891 {
 892         aio_md_cleanup();
 893 }
 894
 895 ATF_TC_WITH_CLEANUP(md_poll);
 896 ATF_TC_HEAD(md_poll, tc)
 897 {
 898
 899         atf_tc_set_md_var(tc, "require.user", "root");
 900 }
 901 ATF_TC_BODY(md_poll, tc)
 902 {
 903         aio_md_test(poll, NULL, false);
 904 }
 905 ATF_TC_CLEANUP(md_poll, tc)
 906 {
 907         aio_md_cleanup();
 908 }
 909
 910 ATF_TC_WITH_CLEANUP(md_signal);
 911 ATF_TC_HEAD(md_signal, tc)
 912 {
 913
 914         atf_tc_set_md_var(tc, "require.user", "root");
 915 }
 916 ATF_TC_BODY(md_signal, tc)
 917 {
 918         aio_md_test(poll_signaled, setup_signal(), false);
 919 }
 920 ATF_TC_CLEANUP(md_signal, tc)
 921 {
 922         aio_md_cleanup();
 923 }
 924
 925 ATF_TC_WITH_CLEANUP(md_suspend);
 926 ATF_TC_HEAD(md_suspend, tc)
 927 {
 928
 929         atf_tc_set_md_var(tc, "require.user", "root");
 930 }
 931 ATF_TC_BODY(md_suspend, tc)
 932 {
 933         aio_md_test(suspend, NULL, false);
 934 }
 935 ATF_TC_CLEANUP(md_suspend, tc)
 936 {
 937         aio_md_cleanup();
 938 }
 939
 940 ATF_TC_WITH_CLEANUP(md_thread);
 941 ATF_TC_HEAD(md_thread, tc)
 942 {
 943
 944         atf_tc_set_md_var(tc, "require.user", "root");
 945 }
 946 ATF_TC_BODY(md_thread, tc)
 947 {
 948         aio_md_test(poll_signaled, setup_thread(), false);
 949 }
 950 ATF_TC_CLEANUP(md_thread, tc)
 951 {
 952         aio_md_cleanup();
 953 }
 954
 955 ATF_TC_WITH_CLEANUP(md_waitcomplete);
 956 ATF_TC_HEAD(md_waitcomplete, tc)
 957 {
 958
 959         atf_tc_set_md_var(tc, "require.user", "root");
 960 }
 961 ATF_TC_BODY(md_waitcomplete, tc)
 962 {
 963         aio_md_test(waitcomplete, NULL, false);
 964 }
 965 ATF_TC_CLEANUP(md_waitcomplete, tc)
 966 {
 967         aio_md_cleanup();
 968 }
 969
 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"
 975
 976 static int
 977 aio_zvol_setup(const char *unique)
 978 {
 979         FILE *pidfile;
 980         int fd;
 981         pid_t pid;
 982         char vdev_name[160];
 983         char pool_name[80];
 984         char cmd[160];
 985         char zvol_name[160];
 986         char devname[160];
 987
 988         ATF_REQUIRE_KERNEL_MODULE("aio");
 989         ATF_REQUIRE_KERNEL_MODULE("zfs");
 990
 991         pid = getpid();
 992         snprintf(vdev_name, sizeof(vdev_name), "%s", ZVOL_VDEV_PATHNAME);
 993         snprintf(pool_name, sizeof(pool_name), "%s_%s.%d", POOL_NAME, unique,
 994             pid);
 995         snprintf(zvol_name, sizeof(zvol_name), "%s/%s_%s", pool_name, ZVOL_NAME,
 996             unique);
 997
 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));
1002         close(fd);
1003
1004         pidfile = fopen("pidfile", "w");
1005         ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
1006         fprintf(pidfile, "%d", pid);
1007         fclose(pidfile);
1008
1009         snprintf(cmd, sizeof(cmd), "zpool create %s $PWD/%s", pool_name,
1010             vdev_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));
1018
1019         snprintf(devname, sizeof(devname), "/dev/zvol/%s", zvol_name);
1020         do {
1021                 fd = open(devname, O_RDWR);
1022         } while (fd == -1 && errno == EINTR);
1023         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1024         return (fd);
1025 }
1026
1027 static void
1028 aio_zvol_cleanup(const char *unique)
1029 {
1030         FILE *pidfile;
1031         pid_t testpid;
1032         char cmd[160];
1033
1034         pidfile = fopen("pidfile", "r");
1035         if (pidfile == NULL && errno == ENOENT) {
1036                 /* Setup probably failed */
1037                 return;
1038         }
1039         ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
1040         ATF_REQUIRE_EQ(1, fscanf(pidfile, "%d", &testpid));
1041         fclose(pidfile);
1042
1043         snprintf(cmd, sizeof(cmd), "zpool destroy %s_%s.%d", POOL_NAME, unique,
1044             testpid);
1045         system(cmd);
1046 }
1047
1048
1049 ATF_TC_WITHOUT_HEAD(aio_large_read_test);
1050 ATF_TC_BODY(aio_large_read_test, tc)
1051 {
1052         struct aiocb cb, *cbp;
1053         ssize_t nread;
1054         size_t len;
1055         int fd;
1056 #ifdef __LP64__
1057         int clamped;
1058 #endif
1059
1060         ATF_REQUIRE_KERNEL_MODULE("aio");
1061         ATF_REQUIRE_UNSAFE_AIO();
1062
1063 #ifdef __LP64__
1064         len = sizeof(clamped);
1065         if (sysctlbyname("debug.iosize_max_clamp", &clamped, &len, NULL, 0) ==
1066             -1)
1067                 atf_libc_error(errno, "Failed to read debug.iosize_max_clamp");
1068 #endif
1069
1070         /* Determine the maximum supported read(2) size. */
1071         len = SSIZE_MAX;
1072 #ifdef __LP64__
1073         if (clamped)
1074                 len = INT_MAX;
1075 #endif
1076
1077         fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1078         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1079
1080         unlink(FILE_PATHNAME);
1081
1082         memset(&cb, 0, sizeof(cb));
1083         cb.aio_nbytes = len;
1084         cb.aio_fildes = fd;
1085         cb.aio_buf = NULL;
1086         if (aio_read(&cb) == -1)
1087                 atf_tc_fail("aio_read() of maximum read size failed: %s",
1088                     strerror(errno));
1089
1090         nread = aio_waitcomplete(&cbp, NULL);
1091         if (nread == -1)
1092                 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1093         if (nread != 0)
1094                 atf_tc_fail("aio_read() from empty file returned data: %zd",
1095                     nread);
1096
1097         memset(&cb, 0, sizeof(cb));
1098         cb.aio_nbytes = len + 1;
1099         cb.aio_fildes = fd;
1100         cb.aio_buf = NULL;
1101         if (aio_read(&cb) == -1) {
1102                 if (errno == EINVAL)
1103                         goto finished;
1104                 atf_tc_fail("aio_read() of too large read size failed: %s",
1105                     strerror(errno));
1106         }
1107
1108         nread = aio_waitcomplete(&cbp, NULL);
1109         if (nread == -1) {
1110                 if (errno == EINVAL)
1111                         goto finished;
1112                 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1113         }
1114         atf_tc_fail("aio_read() of too large read size returned: %zd", nread);
1115
1116 finished:
1117         close(fd);
1118 }
1119
1120 /*
1121  * This tests for a bug where arriving socket data can wakeup multiple
1122  * AIO read requests resulting in an uncancellable request.
1123  */
1124 ATF_TC_WITHOUT_HEAD(aio_socket_two_reads);
1125 ATF_TC_BODY(aio_socket_two_reads, tc)
1126 {
1127         struct ioreq {
1128                 struct aiocb iocb;
1129                 char buffer[1024];
1130         } ioreq[2];
1131         struct aiocb *iocb;
1132         unsigned i;
1133         int s[2];
1134         char c;
1135
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);
1140 #endif
1141
1142         ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1143
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);
1151         }
1152
1153         /* Send a single byte.  This should complete one request. */
1154         c = 0xc3;
1155         ATF_REQUIRE(write(s[1], &c, sizeof(c)) == 1);
1156
1157         ATF_REQUIRE(aio_waitcomplete(&iocb, NULL) == 1);
1158
1159         /* Determine which request completed and verify the data was read. */
1160         if (iocb == &ioreq[0].iocb)
1161                 i = 0;
1162         else
1163                 i = 1;
1164         ATF_REQUIRE(ioreq[i].buffer[0] == c);
1165
1166         i ^= 1;
1167
1168         /*
1169          * Try to cancel the other request.  On broken systems this
1170          * will fail and the process will hang on exit.
1171          */
1172         ATF_REQUIRE(aio_error(&ioreq[i].iocb) == EINPROGRESS);
1173         ATF_REQUIRE(aio_cancel(s[0], &ioreq[i].iocb) == AIO_CANCELED);
1174
1175         close(s[1]);
1176         close(s[0]);
1177 }
1178
1179 static void
1180 aio_socket_blocking_short_write_test(bool vectored)
1181 {
1182         struct aiocb iocb, *iocbp;
1183         struct iovec iov[2];
1184         char *buffer[2];
1185         ssize_t done, r;
1186         int buffer_size, sb_size;
1187         socklen_t len;
1188         int s[2];
1189
1190         ATF_REQUIRE_KERNEL_MODULE("aio");
1191
1192         ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1193
1194         len = sizeof(sb_size);
1195         ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1196             -1);
1197         ATF_REQUIRE(len == sizeof(sb_size));
1198         buffer_size = sb_size;
1199
1200         ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1201             -1);
1202         ATF_REQUIRE(len == sizeof(sb_size));
1203         if (sb_size > buffer_size)
1204                 buffer_size = sb_size;
1205
1206         /*
1207          * Use twice the size of the MAX(receive buffer, send buffer)
1208          * to ensure that the write is split up into multiple writes
1209          * internally.
1210          */
1211         buffer_size *= 2;
1212
1213         buffer[0] = malloc(buffer_size);
1214         ATF_REQUIRE(buffer[0] != NULL);
1215         buffer[1] = malloc(buffer_size);
1216         ATF_REQUIRE(buffer[1] != NULL);
1217
1218         srandomdev();
1219         aio_fill_buffer(buffer[1], buffer_size, random());
1220
1221         memset(&iocb, 0, sizeof(iocb));
1222         iocb.aio_fildes = s[1];
1223         if (vectored) {
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;
1228                 iocb.aio_iov = iov;
1229                 iocb.aio_iovcnt = 2;
1230                 r = aio_writev(&iocb);
1231                 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1232         } else {
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);
1237         }
1238
1239         done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1240         ATF_REQUIRE(done == buffer_size);
1241
1242         done = aio_waitcomplete(&iocbp, NULL);
1243         ATF_REQUIRE(iocbp == &iocb);
1244         ATF_REQUIRE(done == buffer_size);
1245
1246         ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1247
1248         close(s[1]);
1249         close(s[0]);
1250 }
1251
1252 /*
1253  * This test ensures that aio_write() on a blocking socket of a "large"
1254  * buffer does not return a short completion.
1255  */
1256 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write);
1257 ATF_TC_BODY(aio_socket_blocking_short_write, tc)
1258 {
1259         aio_socket_blocking_short_write_test(false);
1260 }
1261
1262 /*
1263  * Like aio_socket_blocking_short_write, but also tests that partially
1264  * completed vectored sends can be retried correctly.
1265  */
1266 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write_vectored);
1267 ATF_TC_BODY(aio_socket_blocking_short_write_vectored, tc)
1268 {
1269         aio_socket_blocking_short_write_test(true);
1270 }
1271
1272 /*
1273  * Verify that AIO requests fail when applied to a listening socket.
1274  */
1275 ATF_TC_WITHOUT_HEAD(aio_socket_listen_fail);
1276 ATF_TC_BODY(aio_socket_listen_fail, tc)
1277 {
1278         struct aiocb iocb;
1279         struct sockaddr_un sun;
1280         char buf[16];
1281         int s;
1282
1283         s = socket(AF_LOCAL, SOCK_STREAM, 0);
1284         ATF_REQUIRE(s != -1);
1285
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);
1291
1292         ATF_REQUIRE(bind(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) == 0);
1293         ATF_REQUIRE(listen(s, 5) == 0);
1294
1295         memset(buf, 0, sizeof(buf));
1296         memset(&iocb, 0, sizeof(iocb));
1297         iocb.aio_fildes = s;
1298         iocb.aio_buf = buf;
1299         iocb.aio_nbytes = sizeof(buf);
1300
1301         ATF_REQUIRE_ERRNO(EINVAL, aio_read(&iocb) == -1);
1302         ATF_REQUIRE_ERRNO(EINVAL, aio_write(&iocb) == -1);
1303
1304         ATF_REQUIRE(unlink(sun.sun_path) == 0);
1305         close(s);
1306 }
1307
1308 /*
1309  * Verify that listen(2) fails if a socket has pending AIO requests.
1310  */
1311 ATF_TC_WITHOUT_HEAD(aio_socket_listen_pending);
1312 ATF_TC_BODY(aio_socket_listen_pending, tc)
1313 {
1314         struct aiocb iocb;
1315         struct sockaddr_un sun;
1316         char buf[16];
1317         int s;
1318
1319         s = socket(AF_LOCAL, SOCK_STREAM, 0);
1320         ATF_REQUIRE(s != -1);
1321
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);
1327
1328         ATF_REQUIRE(bind(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) == 0);
1329
1330         memset(buf, 0, sizeof(buf));
1331         memset(&iocb, 0, sizeof(iocb));
1332         iocb.aio_fildes = s;
1333         iocb.aio_buf = buf;
1334         iocb.aio_nbytes = sizeof(buf);
1335         ATF_REQUIRE(aio_read(&iocb) == 0);
1336
1337         ATF_REQUIRE_ERRNO(EINVAL, listen(s, 5) == -1);
1338
1339         ATF_REQUIRE(aio_cancel(s, &iocb) != -1);
1340
1341         ATF_REQUIRE(unlink(sun.sun_path) == 0);
1342         close(s);
1343 }
1344
1345 /*
1346  * This test verifies that cancelling a partially completed socket write
1347  * returns a short write rather than ECANCELED.
1348  */
1349 ATF_TC_WITHOUT_HEAD(aio_socket_short_write_cancel);
1350 ATF_TC_BODY(aio_socket_short_write_cancel, tc)
1351 {
1352         struct aiocb iocb, *iocbp;
1353         char *buffer[2];
1354         ssize_t done;
1355         int buffer_size, sb_size;
1356         socklen_t len;
1357         int s[2];
1358
1359         ATF_REQUIRE_KERNEL_MODULE("aio");
1360
1361         ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1362
1363         len = sizeof(sb_size);
1364         ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1365             -1);
1366         ATF_REQUIRE(len == sizeof(sb_size));
1367         buffer_size = sb_size;
1368
1369         ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1370             -1);
1371         ATF_REQUIRE(len == sizeof(sb_size));
1372         if (sb_size > buffer_size)
1373                 buffer_size = sb_size;
1374
1375         /*
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.
1382          */
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);
1387
1388         srandomdev();
1389         aio_fill_buffer(buffer[1], buffer_size * 3, random());
1390
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);
1396
1397         done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1398         ATF_REQUIRE(done == buffer_size);
1399
1400         ATF_REQUIRE(aio_error(&iocb) == EINPROGRESS);
1401         ATF_REQUIRE(aio_cancel(s[1], &iocb) == AIO_NOTCANCELED);
1402
1403         done = aio_waitcomplete(&iocbp, NULL);
1404         ATF_REQUIRE(iocbp == &iocb);
1405         ATF_REQUIRE(done >= buffer_size && done <= buffer_size * 2);
1406
1407         ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1408
1409         close(s[1]);
1410         close(s[0]);
1411 }
1412
1413 /*
1414  * Test handling of aio_read() and aio_write() on shut-down sockets.
1415  */
1416 ATF_TC_WITHOUT_HEAD(aio_socket_shutdown);
1417 ATF_TC_BODY(aio_socket_shutdown, tc)
1418 {
1419         struct aiocb iocb;
1420         sigset_t set;
1421         char *buffer;
1422         ssize_t len;
1423         size_t bsz;
1424         int error, s[2];
1425
1426         ATF_REQUIRE_KERNEL_MODULE("aio");
1427
1428         ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1429
1430         bsz = 1024;
1431         buffer = malloc(bsz);
1432         memset(buffer, 0, bsz);
1433
1434         /* Put some data in s[0]'s recv buffer. */
1435         ATF_REQUIRE(send(s[1], buffer, bsz, 0) == (ssize_t)bsz);
1436
1437         /* No more reading from s[0]. */
1438         ATF_REQUIRE(shutdown(s[0], SHUT_RD) != -1);
1439
1440         ATF_REQUIRE(buffer != NULL);
1441
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);
1447
1448         /* Expect to see zero bytes, analogous to recv(2). */
1449         while ((error = aio_error(&iocb)) == EINPROGRESS)
1450                 usleep(25000);
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);
1454
1455         /* No more writing to s[1]. */
1456         ATF_REQUIRE(shutdown(s[1], SHUT_WR) != -1);
1457
1458         /* Block SIGPIPE so that we can detect the error in-band. */
1459         sigemptyset(&set);
1460         sigaddset(&set, SIGPIPE);
1461         ATF_REQUIRE(sigprocmask(SIG_BLOCK, &set, NULL) == 0);
1462
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);
1468
1469         /* Expect an error, analogous to send(2). */
1470         while ((error = aio_error(&iocb)) == EINPROGRESS)
1471                 usleep(25000);
1472         ATF_REQUIRE_MSG(error == EPIPE, "aio_error() returned %d", error);
1473
1474         ATF_REQUIRE(close(s[0]) != -1);
1475         ATF_REQUIRE(close(s[1]) != -1);
1476         free(buffer);
1477 }
1478
1479 /*
1480  * test aio_fsync's behavior with bad inputs
1481  */
1482 ATF_TC_WITHOUT_HEAD(aio_fsync_errors);
1483 ATF_TC_BODY(aio_fsync_errors, tc)
1484 {
1485         int fd;
1486         struct aiocb iocb;
1487
1488         ATF_REQUIRE_KERNEL_MODULE("aio");
1489         ATF_REQUIRE_UNSAFE_AIO();
1490
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);
1494
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);
1500
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);
1506
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);
1513 }
1514
1515 /*
1516  * This test just performs a basic test of aio_fsync().
1517  */
1518 static void
1519 aio_fsync_test(int op)
1520 {
1521         struct aiocb synccb, *iocbp;
1522         struct {
1523                 struct aiocb iocb;
1524                 bool done;
1525                 char *buffer;
1526         } buffers[16];
1527         struct stat sb;
1528         ssize_t rval;
1529         unsigned i;
1530         int fd;
1531
1532         ATF_REQUIRE_KERNEL_MODULE("aio");
1533         ATF_REQUIRE_UNSAFE_AIO();
1534
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);
1538
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);
1542
1543         /*
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.
1547          */
1548         srandomdev();
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);
1559         }
1560
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);
1565
1566         /* Wait for requests to complete. */
1567         for (;;) {
1568         next:
1569                 rval = aio_waitcomplete(&iocbp, NULL);
1570                 ATF_REQUIRE(iocbp != NULL);
1571                 if (iocbp == &synccb) {
1572                         ATF_REQUIRE(rval == 0);
1573                         break;
1574                 }
1575
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;
1581                                 goto next;
1582                         }
1583                 }
1584
1585                 ATF_REQUIRE_MSG(false, "unmatched AIO request");
1586         }
1587
1588         for (i = 0; i < nitems(buffers); i++)
1589                 ATF_REQUIRE_MSG(buffers[i].done,
1590                     "AIO request %u did not complete", i);
1591
1592         close(fd);
1593 }
1594
1595 ATF_TC_WITHOUT_HEAD(aio_fsync_sync_test);
1596 ATF_TC_BODY(aio_fsync_sync_test, tc)
1597 {
1598         aio_fsync_test(O_SYNC);
1599 }
1600
1601 ATF_TC_WITHOUT_HEAD(aio_fsync_dsync_test);
1602 ATF_TC_BODY(aio_fsync_dsync_test, tc)
1603 {
1604         aio_fsync_test(O_DSYNC);
1605 }
1606
1607 /*
1608  * We shouldn't be able to DoS the system by setting iov_len to an insane
1609  * value
1610  */
1611 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iov_len);
1612 ATF_TC_BODY(aio_writev_dos_iov_len, tc)
1613 {
1614         struct aiocb aio;
1615         const struct aiocb *const iocbs[] = {&aio};
1616         const char *wbuf = "Hello, world!";
1617         struct iovec iov[1];
1618         ssize_t r;
1619         int fd;
1620
1621         ATF_REQUIRE_KERNEL_MODULE("aio");
1622         ATF_REQUIRE_UNSAFE_AIO();
1623
1624         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1625         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1626
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;
1631         aio.aio_offset = 0;
1632         aio.aio_iov = iov;
1633         aio.aio_iovcnt = 1;
1634
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));
1642
1643         close(fd);
1644 }
1645
1646 /*
1647  * We shouldn't be able to DoS the system by setting aio_iovcnt to an insane
1648  * value
1649  */
1650 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iovcnt);
1651 ATF_TC_BODY(aio_writev_dos_iovcnt, tc)
1652 {
1653         struct aiocb aio;
1654         const char *wbuf = "Hello, world!";
1655         struct iovec iov[1];
1656         ssize_t len;
1657         int fd;
1658
1659         ATF_REQUIRE_KERNEL_MODULE("aio");
1660         ATF_REQUIRE_UNSAFE_AIO();
1661
1662         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1663         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1664
1665         len = strlen(wbuf);
1666         iov[0].iov_base = __DECONST(void*, wbuf);
1667         iov[0].iov_len = len;
1668         bzero(&aio, sizeof(aio));
1669         aio.aio_fildes = fd;
1670         aio.aio_offset = 0;
1671         aio.aio_iov = iov;
1672         aio.aio_iovcnt = 1 << 30;
1673
1674         ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1675         ATF_CHECK_EQ(EINVAL, errno);
1676
1677         close(fd);
1678 }
1679
1680 ATF_TC_WITH_CLEANUP(aio_writev_efault);
1681 ATF_TC_HEAD(aio_writev_efault, tc)
1682 {
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");
1686 }
1687 ATF_TC_BODY(aio_writev_efault, tc)
1688 {
1689         struct aiocb aio;
1690         ssize_t buflen;
1691         char *buffer;
1692         struct iovec iov[2];
1693         long seed;
1694         int fd;
1695
1696         ATF_REQUIRE_KERNEL_MODULE("aio");
1697         ATF_REQUIRE_UNSAFE_AIO();
1698
1699         fd = aio_md_setup();
1700
1701         seed = random();
1702         buflen = 4096;
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;
1711         aio.aio_offset = 0;
1712         aio.aio_iov = iov;
1713         aio.aio_iovcnt = nitems(iov);
1714
1715         ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1716         ATF_CHECK_EQ(EFAULT, errno);
1717
1718         close(fd);
1719 }
1720 ATF_TC_CLEANUP(aio_writev_efault, tc)
1721 {
1722         aio_md_cleanup();
1723 }
1724
1725 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_poll);
1726 ATF_TC_BODY(aio_writev_empty_file_poll, tc)
1727 {
1728         struct aiocb aio;
1729         int fd;
1730
1731         ATF_REQUIRE_KERNEL_MODULE("aio");
1732         ATF_REQUIRE_UNSAFE_AIO();
1733
1734         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1735         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1736
1737         bzero(&aio, sizeof(aio));
1738         aio.aio_fildes = fd;
1739         aio.aio_offset = 0;
1740         aio.aio_iovcnt = 0;
1741
1742         ATF_REQUIRE_EQ(0, aio_writev(&aio));
1743         ATF_REQUIRE_EQ(0, suspend(&aio));
1744
1745         close(fd);
1746 }
1747
1748 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_signal);
1749 ATF_TC_BODY(aio_writev_empty_file_signal, tc)
1750 {
1751         struct aiocb aio;
1752         int fd;
1753
1754         ATF_REQUIRE_KERNEL_MODULE("aio");
1755         ATF_REQUIRE_UNSAFE_AIO();
1756
1757         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1758         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1759
1760         bzero(&aio, sizeof(aio));
1761         aio.aio_fildes = fd;
1762         aio.aio_offset = 0;
1763         aio.aio_iovcnt = 0;
1764         aio.aio_sigevent = *setup_signal();
1765
1766         ATF_REQUIRE_EQ(0, aio_writev(&aio));
1767         ATF_REQUIRE_EQ(0, poll_signaled(&aio));
1768
1769         close(fd);
1770 }
1771
1772 /*
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.
1775  */
1776 ATF_TC_WITHOUT_HEAD(ev_oneshot);
1777 ATF_TC_BODY(ev_oneshot, tc)
1778 {
1779         int fd, kq, nevents;
1780         struct aiocb iocb;
1781         struct kevent events[1];
1782         struct timespec timeout;
1783
1784         ATF_REQUIRE_KERNEL_MODULE("aio");
1785
1786         kq = kqueue();
1787         ATF_REQUIRE(kq >= 0);
1788
1789         fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1790         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1791
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;
1798
1799         ATF_CHECK_EQ(0, aio_fsync(O_SYNC, &iocb));
1800
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);
1809
1810         /*
1811          * Even though we haven't called aio_return, kevent will not return the
1812          * event again due to EV_ONESHOT.
1813          */
1814         timeout.tv_sec = 0;
1815         timeout.tv_nsec = 100000000;
1816         nevents = kevent(kq, NULL, 0, events, 1, &timeout);
1817         ATF_CHECK_EQ(0, nevents);
1818
1819         ATF_CHECK_EQ(0, aio_return(&iocb));
1820         close(fd);
1821         close(kq);
1822 }
1823
1824
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)
1829 {
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");
1834 }
1835 ATF_TC_BODY(vectored_big_iovcnt, tc)
1836 {
1837         struct aiocb aio;
1838         struct iovec *iov;
1839         ssize_t len, buflen;
1840         char *buffer;
1841         const char *oid = "vfs.aio.max_buf_aio";
1842         long seed;
1843         int max_buf_aio;
1844         int fd, i;
1845         ssize_t sysctl_len = sizeof(max_buf_aio);
1846
1847         ATF_REQUIRE_KERNEL_MODULE("aio");
1848         ATF_REQUIRE_UNSAFE_AIO();
1849
1850         if (sysctlbyname(oid, &max_buf_aio, &sysctl_len, NULL, 0) == -1)
1851                 atf_libc_error(errno, "Failed to read %s", oid);
1852
1853         seed = random();
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));
1858
1859         fd = aio_md_setup();
1860
1861         bzero(&aio, sizeof(aio));
1862         aio.aio_fildes = fd;
1863         aio.aio_offset = 0;
1864         for (i = 0; i < max_buf_aio + 1; i++) {
1865                 iov[i].iov_base = &buffer[i * 512];
1866                 iov[i].iov_len = 512;
1867         }
1868         aio.aio_iov = iov;
1869         aio.aio_iovcnt = max_buf_aio + 1;
1870
1871         if (aio_writev(&aio) < 0)
1872                 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1873
1874         len = poll(&aio);
1875         if (len < 0)
1876                 atf_tc_fail("aio failed: %s", strerror(errno));
1877
1878         if (len != buflen)
1879                 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
1880
1881         bzero(&aio, sizeof(aio));
1882         aio.aio_fildes = fd;
1883         aio.aio_offset = 0;
1884         aio.aio_iov = iov;
1885         aio.aio_iovcnt = max_buf_aio + 1;
1886
1887         if (aio_readv(&aio) < 0)
1888                 atf_tc_fail("aio_readv failed: %s", strerror(errno));
1889
1890         len = poll(&aio);
1891         if (len < 0)
1892                 atf_tc_fail("aio failed: %s", strerror(errno));
1893
1894         if (len != buflen)
1895                 atf_tc_fail("aio short read (%jd)", (intmax_t)len);
1896
1897         if (aio_test_buffer(buffer, buflen, seed) == 0)
1898                 atf_tc_fail("buffer mismatched");
1899
1900         close(fd);
1901 }
1902 ATF_TC_CLEANUP(vectored_big_iovcnt, tc)
1903 {
1904         aio_md_cleanup();
1905 }
1906
1907 ATF_TC_WITHOUT_HEAD(vectored_file_poll);
1908 ATF_TC_BODY(vectored_file_poll, tc)
1909 {
1910         aio_file_test(poll, NULL, true);
1911 }
1912
1913 ATF_TC_WITHOUT_HEAD(vectored_thread);
1914 ATF_TC_BODY(vectored_thread, tc)
1915 {
1916         aio_file_test(poll_signaled, setup_thread(), true);
1917 }
1918
1919 ATF_TC_WITH_CLEANUP(vectored_md_poll);
1920 ATF_TC_HEAD(vectored_md_poll, tc)
1921 {
1922         atf_tc_set_md_var(tc, "require.user", "root");
1923 }
1924 ATF_TC_BODY(vectored_md_poll, tc)
1925 {
1926         aio_md_test(poll, NULL, true);
1927 }
1928 ATF_TC_CLEANUP(vectored_md_poll, tc)
1929 {
1930         aio_md_cleanup();
1931 }
1932
1933 ATF_TC_WITHOUT_HEAD(vectored_socket_poll);
1934 ATF_TC_BODY(vectored_socket_poll, tc)
1935 {
1936         aio_unix_socketpair_test(poll, NULL, true);
1937 }
1938
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)
1944 {
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");
1949 }
1950 ATF_TC_BODY(vectored_unaligned, tc)
1951 {
1952         struct aio_context ac;
1953         struct aiocb aio;
1954         struct iovec iov[3];
1955         ssize_t len, total_len;
1956         int fd;
1957
1958         if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false))
1959                 atf_tc_skip("https://bugs.freebsd.org/258766");
1960
1961         ATF_REQUIRE_KERNEL_MODULE("aio");
1962         ATF_REQUIRE_UNSAFE_AIO();
1963
1964         /*
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.
1967          */
1968         fd = aio_zvol_setup(atf_tc_get_ident(tc));
1969         aio_context_init(&ac, fd, fd, FILE_LEN);
1970
1971         /* Break the buffer into 3 parts:
1972          * * A 4kB part, aligned to 4kB
1973          * * Two other parts that add up to 4kB:
1974          *   - 256B
1975          *   - 4kB - 256B
1976          */
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;
1986         aio.aio_offset = 0;
1987         aio.aio_iov = iov;
1988         aio.aio_iovcnt = 3;
1989
1990         if (aio_writev(&aio) < 0)
1991                 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1992
1993         len = poll(&aio);
1994         if (len < 0)
1995                 atf_tc_fail("aio failed: %s", strerror(errno));
1996
1997         if (len != total_len)
1998                 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
1999
2000         bzero(&aio, sizeof(aio));
2001         aio.aio_fildes = ac.ac_read_fd;
2002         aio.aio_offset = 0;
2003         aio.aio_iov = iov;
2004         aio.aio_iovcnt = 3;
2005
2006         if (aio_readv(&aio) < 0)
2007                 atf_tc_fail("aio_readv failed: %s", strerror(errno));
2008         len = poll(&aio);
2009
2010         ATF_REQUIRE_MSG(aio_test_buffer(ac.ac_buffer, total_len,
2011             ac.ac_seed) != 0, "aio_test_buffer: internal error");
2012
2013         close(fd);
2014 }
2015 ATF_TC_CLEANUP(vectored_unaligned, tc)
2016 {
2017         aio_zvol_cleanup(atf_tc_get_ident(tc));
2018 }
2019
2020 static void
2021 aio_zvol_test(completion comp, struct sigevent *sev, bool vectored,
2022     const char *unique)
2023 {
2024         struct aio_context ac;
2025         int fd;
2026
2027         fd = aio_zvol_setup(unique);
2028         aio_context_init(&ac, fd, fd, MD_LEN);
2029         if (vectored) {
2030                 aio_writev_test(&ac, comp, sev);
2031                 aio_readv_test(&ac, comp, sev);
2032         } else {
2033                 aio_write_test(&ac, comp, sev);
2034                 aio_read_test(&ac, comp, sev);
2035         }
2036
2037         close(fd);
2038 }
2039
2040 /*
2041  * Note that unlike md, the zvol is not a geom device, does not allow unmapped
2042  * buffers, and does not use physio.
2043  */
2044 ATF_TC_WITH_CLEANUP(vectored_zvol_poll);
2045 ATF_TC_HEAD(vectored_zvol_poll, tc)
2046 {
2047         atf_tc_set_md_var(tc, "require.user", "root");
2048 }
2049 ATF_TC_BODY(vectored_zvol_poll, tc)
2050 {
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));
2054 }
2055 ATF_TC_CLEANUP(vectored_zvol_poll, tc)
2056 {
2057         aio_zvol_cleanup(atf_tc_get_ident(tc));
2058 }
2059
2060 ATF_TP_ADD_TCS(tp)
2061 {
2062
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);
2100
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);
2126
2127         return (atf_no_error());
2128 }