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  * $FreeBSD$
  27  */
  28
  29 /*
  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
  39  * types.
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/module.h>
  44 #include <sys/resource.h>
  45 #include <sys/socket.h>
  46 #include <sys/stat.h>
  47 #include <sys/mdioctl.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 <stdint.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60 #include <termios.h>
  61 #include <unistd.h>
  62
  63 #include <atf-c.h>
  64
  65 #include "freebsd_test_suite/macros.h"
  66 #include "local.h"
  67
  68 /*
  69  * GLOBAL_MAX sets the largest usable buffer size to be read and written, as
  70  * it sizes ac_buffer in the aio_context structure.  It is also the default
  71  * size for file I/O.  For other types, we use smaller blocks or we risk
  72  * blocking (and we run in a single process/thread so that would be bad).
  73  */
  74 #define GLOBAL_MAX      16384
  75
  76 #define BUFFER_MAX      GLOBAL_MAX
  77
  78 /*
  79  * A completion function will block until the aio has completed, then return
  80  * the result of the aio.  errno will be set appropriately.
  81  */
  82 typedef ssize_t (*completion)(struct aiocb*);
  83
  84 struct aio_context {
  85         int              ac_read_fd, ac_write_fd;
  86         long             ac_seed;
  87         char             ac_buffer[GLOBAL_MAX];
  88         int              ac_buflen;
  89         int              ac_seconds;
  90 };
  91
  92 static sem_t            completions;
  93
  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  * Perform a simple write test of our initialized data buffer to the provided
 257  * file descriptor.
 258  */
 259 static void
 260 aio_write_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 261 {
 262         struct aiocb aio;
 263         ssize_t len;
 264
 265         bzero(&aio, sizeof(aio));
 266         aio.aio_buf = ac->ac_buffer;
 267         aio.aio_nbytes = ac->ac_buflen;
 268         aio.aio_fildes = ac->ac_write_fd;
 269         aio.aio_offset = 0;
 270         if (sev)
 271                 aio.aio_sigevent = *sev;
 272
 273         if (aio_write(&aio) < 0)
 274                 atf_tc_fail("aio_write failed: %s", strerror(errno));
 275
 276         len = comp(&aio);
 277         if (len < 0)
 278                 atf_tc_fail("aio failed: %s", strerror(errno));
 279
 280         if (len != ac->ac_buflen)
 281                 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
 282 }
 283
 284 /*
 285  * Perform a vectored I/O test of our initialized data buffer to the provided
 286  * file descriptor.
 287  *
 288  * To vectorize the linear buffer, chop it up into two pieces of dissimilar
 289  * size, and swap their offsets.
 290  */
 291 static void
 292 aio_writev_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 293 {
 294         struct aiocb aio;
 295         struct iovec iov[2];
 296         size_t len0, len1;
 297         ssize_t len;
 298
 299         bzero(&aio, sizeof(aio));
 300
 301         aio.aio_fildes = ac->ac_write_fd;
 302         aio.aio_offset = 0;
 303         len0 = ac->ac_buflen * 3 / 4;
 304         len1 = ac->ac_buflen / 4;
 305         iov[0].iov_base = ac->ac_buffer + len1;
 306         iov[0].iov_len = len0;
 307         iov[1].iov_base = ac->ac_buffer;
 308         iov[1].iov_len = len1;
 309         aio.aio_iov = iov;
 310         aio.aio_iovcnt = 2;
 311         if (sev)
 312                 aio.aio_sigevent = *sev;
 313
 314         if (aio_writev(&aio) < 0)
 315                 atf_tc_fail("aio_writev 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 simple read test of our initialized data buffer from the
 327  * provided file descriptor.
 328  */
 329 static void
 330 aio_read_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 331 {
 332         struct aiocb aio;
 333         ssize_t len;
 334
 335         bzero(ac->ac_buffer, ac->ac_buflen);
 336         bzero(&aio, sizeof(aio));
 337         aio.aio_buf = ac->ac_buffer;
 338         aio.aio_nbytes = ac->ac_buflen;
 339         aio.aio_fildes = ac->ac_read_fd;
 340         aio.aio_offset = 0;
 341         if (sev)
 342                 aio.aio_sigevent = *sev;
 343
 344         if (aio_read(&aio) < 0)
 345                 atf_tc_fail("aio_read failed: %s", strerror(errno));
 346
 347         len = comp(&aio);
 348         if (len < 0)
 349                 atf_tc_fail("aio failed: %s", strerror(errno));
 350
 351         ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
 352             "aio short read (%jd)", (intmax_t)len);
 353
 354         if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
 355                 atf_tc_fail("buffer mismatched");
 356 }
 357
 358 static void
 359 aio_readv_test(struct aio_context *ac, completion comp, struct sigevent *sev)
 360 {
 361         struct aiocb aio;
 362         struct iovec iov[2];
 363         size_t len0, len1;
 364         ssize_t len;
 365
 366         bzero(ac->ac_buffer, ac->ac_buflen);
 367         bzero(&aio, sizeof(aio));
 368         aio.aio_fildes = ac->ac_read_fd;
 369         aio.aio_offset = 0;
 370         len0 = ac->ac_buflen * 3 / 4;
 371         len1 = ac->ac_buflen / 4;
 372         iov[0].iov_base = ac->ac_buffer + len1;
 373         iov[0].iov_len = len0;
 374         iov[1].iov_base = ac->ac_buffer;
 375         iov[1].iov_len = len1;
 376         aio.aio_iov = iov;
 377         aio.aio_iovcnt = 2;
 378         if (sev)
 379                 aio.aio_sigevent = *sev;
 380
 381         if (aio_readv(&aio) < 0)
 382                 atf_tc_fail("aio_read failed: %s", strerror(errno));
 383
 384         len = comp(&aio);
 385         if (len < 0)
 386                 atf_tc_fail("aio failed: %s", strerror(errno));
 387
 388         ATF_REQUIRE_EQ_MSG(len, ac->ac_buflen,
 389             "aio short read (%jd)", (intmax_t)len);
 390
 391         if (aio_test_buffer(ac->ac_buffer, ac->ac_buflen, ac->ac_seed) == 0)
 392                 atf_tc_fail("buffer mismatched");
 393 }
 394
 395 /*
 396  * Series of type-specific tests for AIO.  For now, we just make sure we can
 397  * issue a write and then a read to each type.  We assume that once a write
 398  * is issued, a read can follow.
 399  */
 400
 401 /*
 402  * Test with a classic file.  Assumes we can create a moderate size temporary
 403  * file.
 404  */
 405 #define FILE_LEN        GLOBAL_MAX
 406 #define FILE_PATHNAME   "testfile"
 407
 408 static void
 409 aio_file_test(completion comp, struct sigevent *sev, bool vectored)
 410 {
 411         struct aio_context ac;
 412         int fd;
 413
 414         ATF_REQUIRE_KERNEL_MODULE("aio");
 415         ATF_REQUIRE_UNSAFE_AIO();
 416
 417         fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
 418         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
 419
 420         aio_context_init(&ac, fd, fd, FILE_LEN);
 421         if (vectored) {
 422                 aio_writev_test(&ac, comp, sev);
 423                 aio_readv_test(&ac, comp, sev);
 424         } else {
 425                 aio_write_test(&ac, comp, sev);
 426                 aio_read_test(&ac, comp, sev);
 427         }
 428         close(fd);
 429 }
 430
 431 ATF_TC_WITHOUT_HEAD(file_poll);
 432 ATF_TC_BODY(file_poll, tc)
 433 {
 434         aio_file_test(poll, NULL, false);
 435 }
 436
 437 ATF_TC_WITHOUT_HEAD(file_signal);
 438 ATF_TC_BODY(file_signal, tc)
 439 {
 440         aio_file_test(poll_signaled, setup_signal(), false);
 441 }
 442
 443 ATF_TC_WITHOUT_HEAD(file_suspend);
 444 ATF_TC_BODY(file_suspend, tc)
 445 {
 446         aio_file_test(suspend, NULL, false);
 447 }
 448
 449 ATF_TC_WITHOUT_HEAD(file_thread);
 450 ATF_TC_BODY(file_thread, tc)
 451 {
 452         aio_file_test(poll_signaled, setup_thread(), false);
 453 }
 454
 455 ATF_TC_WITHOUT_HEAD(file_waitcomplete);
 456 ATF_TC_BODY(file_waitcomplete, tc)
 457 {
 458         aio_file_test(waitcomplete, NULL, false);
 459 }
 460
 461 #define FIFO_LEN        256
 462 #define FIFO_PATHNAME   "testfifo"
 463
 464 static void
 465 aio_fifo_test(completion comp, struct sigevent *sev)
 466 {
 467         int error, read_fd = -1, write_fd = -1;
 468         struct aio_context ac;
 469
 470         ATF_REQUIRE_KERNEL_MODULE("aio");
 471         ATF_REQUIRE_UNSAFE_AIO();
 472
 473         ATF_REQUIRE_MSG(mkfifo(FIFO_PATHNAME, 0600) != -1,
 474             "mkfifo failed: %s", strerror(errno));
 475
 476         read_fd = open(FIFO_PATHNAME, O_RDONLY | O_NONBLOCK);
 477         if (read_fd == -1) {
 478                 error = errno;
 479                 errno = error;
 480                 atf_tc_fail("read_fd open failed: %s",
 481                     strerror(errno));
 482         }
 483
 484         write_fd = open(FIFO_PATHNAME, O_WRONLY);
 485         if (write_fd == -1) {
 486                 error = errno;
 487                 errno = error;
 488                 atf_tc_fail("write_fd open failed: %s",
 489                     strerror(errno));
 490         }
 491
 492         aio_context_init(&ac, read_fd, write_fd, FIFO_LEN);
 493         aio_write_test(&ac, comp, sev);
 494         aio_read_test(&ac, comp, sev);
 495
 496         close(read_fd);
 497         close(write_fd);
 498 }
 499
 500 ATF_TC_WITHOUT_HEAD(fifo_poll);
 501 ATF_TC_BODY(fifo_poll, tc)
 502 {
 503         aio_fifo_test(poll, NULL);
 504 }
 505
 506 ATF_TC_WITHOUT_HEAD(fifo_signal);
 507 ATF_TC_BODY(fifo_signal, tc)
 508 {
 509         aio_fifo_test(poll_signaled, setup_signal());
 510 }
 511
 512 ATF_TC_WITHOUT_HEAD(fifo_suspend);
 513 ATF_TC_BODY(fifo_suspend, tc)
 514 {
 515         aio_fifo_test(suspend, NULL);
 516 }
 517
 518 ATF_TC_WITHOUT_HEAD(fifo_thread);
 519 ATF_TC_BODY(fifo_thread, tc)
 520 {
 521         aio_fifo_test(poll_signaled, setup_thread());
 522 }
 523
 524 ATF_TC_WITHOUT_HEAD(fifo_waitcomplete);
 525 ATF_TC_BODY(fifo_waitcomplete, tc)
 526 {
 527         aio_fifo_test(waitcomplete, NULL);
 528 }
 529
 530 #define UNIX_SOCKETPAIR_LEN     256
 531 static void
 532 aio_unix_socketpair_test(completion comp, struct sigevent *sev, bool vectored)
 533 {
 534         struct aio_context ac;
 535         struct rusage ru_before, ru_after;
 536         int sockets[2];
 537
 538         ATF_REQUIRE_KERNEL_MODULE("aio");
 539
 540         ATF_REQUIRE_MSG(socketpair(PF_UNIX, SOCK_STREAM, 0, sockets) != -1,
 541             "socketpair failed: %s", strerror(errno));
 542
 543         aio_context_init(&ac, sockets[0], sockets[1], UNIX_SOCKETPAIR_LEN);
 544         ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_before) != -1,
 545             "getrusage failed: %s", strerror(errno));
 546         if (vectored) {
 547                 aio_writev_test(&ac, comp, sev);
 548                 aio_readv_test(&ac, comp, sev);
 549         } else {
 550                 aio_write_test(&ac, comp, sev);
 551                 aio_read_test(&ac, comp, sev);
 552         }
 553         ATF_REQUIRE_MSG(getrusage(RUSAGE_SELF, &ru_after) != -1,
 554             "getrusage failed: %s", strerror(errno));
 555         ATF_REQUIRE(ru_after.ru_msgsnd == ru_before.ru_msgsnd + 1);
 556         ATF_REQUIRE(ru_after.ru_msgrcv == ru_before.ru_msgrcv + 1);
 557
 558         close(sockets[0]);
 559         close(sockets[1]);
 560 }
 561
 562 ATF_TC_WITHOUT_HEAD(socket_poll);
 563 ATF_TC_BODY(socket_poll, tc)
 564 {
 565         aio_unix_socketpair_test(poll, NULL, false);
 566 }
 567
 568 ATF_TC_WITHOUT_HEAD(socket_signal);
 569 ATF_TC_BODY(socket_signal, tc)
 570 {
 571         aio_unix_socketpair_test(poll_signaled, setup_signal(), false);
 572 }
 573
 574 ATF_TC_WITHOUT_HEAD(socket_suspend);
 575 ATF_TC_BODY(socket_suspend, tc)
 576 {
 577         aio_unix_socketpair_test(suspend, NULL, false);
 578 }
 579
 580 ATF_TC_WITHOUT_HEAD(socket_thread);
 581 ATF_TC_BODY(socket_thread, tc)
 582 {
 583         aio_unix_socketpair_test(poll_signaled, setup_thread(), false);
 584 }
 585
 586 ATF_TC_WITHOUT_HEAD(socket_waitcomplete);
 587 ATF_TC_BODY(socket_waitcomplete, tc)
 588 {
 589         aio_unix_socketpair_test(waitcomplete, NULL, false);
 590 }
 591
 592 struct aio_pty_arg {
 593         int     apa_read_fd;
 594         int     apa_write_fd;
 595 };
 596
 597 #define PTY_LEN         256
 598 static void
 599 aio_pty_test(completion comp, struct sigevent *sev)
 600 {
 601         struct aio_context ac;
 602         int read_fd, write_fd;
 603         struct termios ts;
 604         int error;
 605
 606         ATF_REQUIRE_KERNEL_MODULE("aio");
 607         ATF_REQUIRE_UNSAFE_AIO();
 608
 609         ATF_REQUIRE_MSG(openpty(&read_fd, &write_fd, NULL, NULL, NULL) == 0,
 610             "openpty failed: %s", strerror(errno));
 611
 612
 613         if (tcgetattr(write_fd, &ts) < 0) {
 614                 error = errno;
 615                 errno = error;
 616                 atf_tc_fail("tcgetattr failed: %s", strerror(errno));
 617         }
 618         cfmakeraw(&ts);
 619         if (tcsetattr(write_fd, TCSANOW, &ts) < 0) {
 620                 error = errno;
 621                 errno = error;
 622                 atf_tc_fail("tcsetattr failed: %s", strerror(errno));
 623         }
 624         aio_context_init(&ac, read_fd, write_fd, PTY_LEN);
 625
 626         aio_write_test(&ac, comp, sev);
 627         aio_read_test(&ac, comp, sev);
 628
 629         close(read_fd);
 630         close(write_fd);
 631 }
 632
 633 ATF_TC_WITHOUT_HEAD(pty_poll);
 634 ATF_TC_BODY(pty_poll, tc)
 635 {
 636         aio_pty_test(poll, NULL);
 637 }
 638
 639 ATF_TC_WITHOUT_HEAD(pty_signal);
 640 ATF_TC_BODY(pty_signal, tc)
 641 {
 642         aio_pty_test(poll_signaled, setup_signal());
 643 }
 644
 645 ATF_TC_WITHOUT_HEAD(pty_suspend);
 646 ATF_TC_BODY(pty_suspend, tc)
 647 {
 648         aio_pty_test(suspend, NULL);
 649 }
 650
 651 ATF_TC_WITHOUT_HEAD(pty_thread);
 652 ATF_TC_BODY(pty_thread, tc)
 653 {
 654         aio_pty_test(poll_signaled, setup_thread());
 655 }
 656
 657 ATF_TC_WITHOUT_HEAD(pty_waitcomplete);
 658 ATF_TC_BODY(pty_waitcomplete, tc)
 659 {
 660         aio_pty_test(waitcomplete, NULL);
 661 }
 662
 663 #define PIPE_LEN        256
 664 static void
 665 aio_pipe_test(completion comp, struct sigevent *sev)
 666 {
 667         struct aio_context ac;
 668         int pipes[2];
 669
 670         ATF_REQUIRE_KERNEL_MODULE("aio");
 671         ATF_REQUIRE_UNSAFE_AIO();
 672
 673         ATF_REQUIRE_MSG(pipe(pipes) != -1,
 674             "pipe failed: %s", strerror(errno));
 675
 676         aio_context_init(&ac, pipes[0], pipes[1], PIPE_LEN);
 677         aio_write_test(&ac, comp, sev);
 678         aio_read_test(&ac, comp, sev);
 679
 680         close(pipes[0]);
 681         close(pipes[1]);
 682 }
 683
 684 ATF_TC_WITHOUT_HEAD(pipe_poll);
 685 ATF_TC_BODY(pipe_poll, tc)
 686 {
 687         aio_pipe_test(poll, NULL);
 688 }
 689
 690 ATF_TC_WITHOUT_HEAD(pipe_signal);
 691 ATF_TC_BODY(pipe_signal, tc)
 692 {
 693         aio_pipe_test(poll_signaled, setup_signal());
 694 }
 695
 696 ATF_TC_WITHOUT_HEAD(pipe_suspend);
 697 ATF_TC_BODY(pipe_suspend, tc)
 698 {
 699         aio_pipe_test(suspend, NULL);
 700 }
 701
 702 ATF_TC_WITHOUT_HEAD(pipe_thread);
 703 ATF_TC_BODY(pipe_thread, tc)
 704 {
 705         aio_pipe_test(poll_signaled, setup_thread());
 706 }
 707
 708 ATF_TC_WITHOUT_HEAD(pipe_waitcomplete);
 709 ATF_TC_BODY(pipe_waitcomplete, tc)
 710 {
 711         aio_pipe_test(waitcomplete, NULL);
 712 }
 713
 714 #define MD_LEN          GLOBAL_MAX
 715 #define MDUNIT_LINK     "mdunit_link"
 716
 717 static int
 718 aio_md_setup(void)
 719 {
 720         int error, fd, mdctl_fd, unit;
 721         char pathname[PATH_MAX];
 722         struct md_ioctl mdio;
 723         char buf[80];
 724
 725         ATF_REQUIRE_KERNEL_MODULE("aio");
 726
 727         mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
 728         ATF_REQUIRE_MSG(mdctl_fd != -1,
 729             "opening /dev/%s failed: %s", MDCTL_NAME, strerror(errno));
 730
 731         bzero(&mdio, sizeof(mdio));
 732         mdio.md_version = MDIOVERSION;
 733         mdio.md_type = MD_MALLOC;
 734         mdio.md_options = MD_AUTOUNIT | MD_COMPRESS;
 735         mdio.md_mediasize = GLOBAL_MAX;
 736         mdio.md_sectorsize = 512;
 737         strlcpy(buf, __func__, sizeof(buf));
 738         mdio.md_label = buf;
 739
 740         if (ioctl(mdctl_fd, MDIOCATTACH, &mdio) < 0) {
 741                 error = errno;
 742                 errno = error;
 743                 atf_tc_fail("ioctl MDIOCATTACH failed: %s", strerror(errno));
 744         }
 745         close(mdctl_fd);
 746
 747         /* Store the md unit number in a symlink for future cleanup */
 748         unit = mdio.md_unit;
 749         snprintf(buf, sizeof(buf), "%d", unit);
 750         ATF_REQUIRE_EQ(0, symlink(buf, MDUNIT_LINK));
 751         snprintf(pathname, PATH_MAX, "/dev/md%d", unit);
 752         fd = open(pathname, O_RDWR);
 753         ATF_REQUIRE_MSG(fd != -1,
 754             "opening %s failed: %s", pathname, strerror(errno));
 755
 756         return (fd);
 757 }
 758
 759 static void
 760 aio_md_cleanup(void)
 761 {
 762         struct md_ioctl mdio;
 763         int mdctl_fd, n, unit;
 764         char buf[80];
 765
 766         mdctl_fd = open("/dev/" MDCTL_NAME, O_RDWR, 0);
 767         if (mdctl_fd < 0) {
 768                 fprintf(stderr, "opening /dev/%s failed: %s\n", MDCTL_NAME,
 769                     strerror(errno));
 770                 return;
 771         }
 772         n = readlink(MDUNIT_LINK, buf, sizeof(buf) - 1);
 773         if (n > 0) {
 774                 buf[n] = '\0';
 775                 if (sscanf(buf, "%d", &unit) == 1 && unit >= 0) {
 776                         bzero(&mdio, sizeof(mdio));
 777                         mdio.md_version = MDIOVERSION;
 778                         mdio.md_unit = unit;
 779                         if (ioctl(mdctl_fd, MDIOCDETACH, &mdio) == -1) {
 780                                 fprintf(stderr,
 781                                     "ioctl MDIOCDETACH unit %d failed: %s\n",
 782                                     unit, strerror(errno));
 783                         }
 784                 }
 785         }
 786
 787         close(mdctl_fd);
 788 }
 789
 790 static void
 791 aio_md_test(completion comp, struct sigevent *sev, bool vectored)
 792 {
 793         struct aio_context ac;
 794         int fd;
 795
 796         fd = aio_md_setup();
 797         aio_context_init(&ac, fd, fd, MD_LEN);
 798         if (vectored) {
 799                 aio_writev_test(&ac, comp, sev);
 800                 aio_readv_test(&ac, comp, sev);
 801         } else {
 802                 aio_write_test(&ac, comp, sev);
 803                 aio_read_test(&ac, comp, sev);
 804         }
 805
 806         close(fd);
 807 }
 808
 809 ATF_TC_WITH_CLEANUP(md_poll);
 810 ATF_TC_HEAD(md_poll, tc)
 811 {
 812
 813         atf_tc_set_md_var(tc, "require.user", "root");
 814 }
 815 ATF_TC_BODY(md_poll, tc)
 816 {
 817         aio_md_test(poll, NULL, false);
 818 }
 819 ATF_TC_CLEANUP(md_poll, tc)
 820 {
 821         aio_md_cleanup();
 822 }
 823
 824 ATF_TC_WITH_CLEANUP(md_signal);
 825 ATF_TC_HEAD(md_signal, tc)
 826 {
 827
 828         atf_tc_set_md_var(tc, "require.user", "root");
 829 }
 830 ATF_TC_BODY(md_signal, tc)
 831 {
 832         aio_md_test(poll_signaled, setup_signal(), false);
 833 }
 834 ATF_TC_CLEANUP(md_signal, tc)
 835 {
 836         aio_md_cleanup();
 837 }
 838
 839 ATF_TC_WITH_CLEANUP(md_suspend);
 840 ATF_TC_HEAD(md_suspend, tc)
 841 {
 842
 843         atf_tc_set_md_var(tc, "require.user", "root");
 844 }
 845 ATF_TC_BODY(md_suspend, tc)
 846 {
 847         aio_md_test(suspend, NULL, false);
 848 }
 849 ATF_TC_CLEANUP(md_suspend, tc)
 850 {
 851         aio_md_cleanup();
 852 }
 853
 854 ATF_TC_WITH_CLEANUP(md_thread);
 855 ATF_TC_HEAD(md_thread, tc)
 856 {
 857
 858         atf_tc_set_md_var(tc, "require.user", "root");
 859 }
 860 ATF_TC_BODY(md_thread, tc)
 861 {
 862         aio_md_test(poll_signaled, setup_thread(), false);
 863 }
 864 ATF_TC_CLEANUP(md_thread, tc)
 865 {
 866         aio_md_cleanup();
 867 }
 868
 869 ATF_TC_WITH_CLEANUP(md_waitcomplete);
 870 ATF_TC_HEAD(md_waitcomplete, tc)
 871 {
 872
 873         atf_tc_set_md_var(tc, "require.user", "root");
 874 }
 875 ATF_TC_BODY(md_waitcomplete, tc)
 876 {
 877         aio_md_test(waitcomplete, NULL, false);
 878 }
 879 ATF_TC_CLEANUP(md_waitcomplete, tc)
 880 {
 881         aio_md_cleanup();
 882 }
 883
 884 #define ZVOL_VDEV_PATHNAME      "test_vdev"
 885 #define POOL_SIZE               (1 << 28)       /* 256 MB */
 886 #define ZVOL_SIZE               "64m"
 887 #define POOL_NAME               "aio_testpool"
 888 #define ZVOL_NAME               "aio_testvol"
 889
 890 static int
 891 aio_zvol_setup(void)
 892 {
 893         FILE *pidfile;
 894         int fd;
 895         pid_t pid;
 896         char pool_name[80];
 897         char cmd[160];
 898         char zvol_name[160];
 899         char devname[160];
 900
 901         ATF_REQUIRE_KERNEL_MODULE("aio");
 902         ATF_REQUIRE_KERNEL_MODULE("zfs");
 903
 904         fd = open(ZVOL_VDEV_PATHNAME, O_RDWR | O_CREAT, 0600);
 905         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
 906         ATF_REQUIRE_EQ_MSG(0,
 907             ftruncate(fd, POOL_SIZE), "ftruncate failed: %s", strerror(errno));
 908         close(fd);
 909
 910         pid = getpid();
 911         pidfile = fopen("pidfile", "w");
 912         ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
 913         fprintf(pidfile, "%d", pid);
 914         fclose(pidfile);
 915
 916         snprintf(pool_name, sizeof(pool_name), POOL_NAME ".%d", pid);
 917         snprintf(zvol_name, sizeof(zvol_name), "%s/" ZVOL_NAME, pool_name);
 918         snprintf(cmd, sizeof(cmd), "zpool create %s $PWD/" ZVOL_VDEV_PATHNAME,
 919             pool_name);
 920         ATF_REQUIRE_EQ_MSG(0, system(cmd),
 921             "zpool create failed: %s", strerror(errno));
 922         snprintf(cmd, sizeof(cmd),
 923             "zfs create -o volblocksize=8192 -o volmode=dev -V "
 924                 ZVOL_SIZE " %s", zvol_name);
 925         ATF_REQUIRE_EQ_MSG(0, system(cmd),
 926             "zfs create failed: %s", strerror(errno));
 927
 928         snprintf(devname, sizeof(devname), "/dev/zvol/%s", zvol_name);
 929         do {
 930                 fd = open(devname, O_RDWR);
 931         } while (fd == -1 && errno == EINTR) ;
 932         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
 933         return (fd);
 934 }
 935
 936 static void
 937 aio_zvol_cleanup(void)
 938 {
 939         FILE *pidfile;
 940         pid_t testpid;
 941         char cmd[160];
 942
 943         pidfile = fopen("pidfile", "r");
 944         if (pidfile == NULL && errno == ENOENT) {
 945                 /* Setup probably failed */
 946                 return;
 947         }
 948         ATF_REQUIRE_MSG(NULL != pidfile, "fopen: %s", strerror(errno));
 949         ATF_REQUIRE_EQ(1, fscanf(pidfile, "%d", &testpid));
 950         fclose(pidfile);
 951
 952         snprintf(cmd, sizeof(cmd), "zpool destroy " POOL_NAME ".%d", testpid);
 953         system(cmd);
 954 }
 955
 956
 957 ATF_TC_WITHOUT_HEAD(aio_large_read_test);
 958 ATF_TC_BODY(aio_large_read_test, tc)
 959 {
 960         struct aiocb cb, *cbp;
 961         ssize_t nread;
 962         size_t len;
 963         int fd;
 964 #ifdef __LP64__
 965         int clamped;
 966 #endif
 967
 968         ATF_REQUIRE_KERNEL_MODULE("aio");
 969         ATF_REQUIRE_UNSAFE_AIO();
 970
 971 #ifdef __LP64__
 972         len = sizeof(clamped);
 973         if (sysctlbyname("debug.iosize_max_clamp", &clamped, &len, NULL, 0) ==
 974             -1)
 975                 atf_libc_error(errno, "Failed to read debug.iosize_max_clamp");
 976 #endif
 977
 978         /* Determine the maximum supported read(2) size. */
 979         len = SSIZE_MAX;
 980 #ifdef __LP64__
 981         if (clamped)
 982                 len = INT_MAX;
 983 #endif
 984
 985         fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
 986         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
 987
 988         unlink(FILE_PATHNAME);
 989
 990         memset(&cb, 0, sizeof(cb));
 991         cb.aio_nbytes = len;
 992         cb.aio_fildes = fd;
 993         cb.aio_buf = NULL;
 994         if (aio_read(&cb) == -1)
 995                 atf_tc_fail("aio_read() of maximum read size failed: %s",
 996                     strerror(errno));
 997
 998         nread = aio_waitcomplete(&cbp, NULL);
 999         if (nread == -1)
1000                 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1001         if (nread != 0)
1002                 atf_tc_fail("aio_read() from empty file returned data: %zd",
1003                     nread);
1004
1005         memset(&cb, 0, sizeof(cb));
1006         cb.aio_nbytes = len + 1;
1007         cb.aio_fildes = fd;
1008         cb.aio_buf = NULL;
1009         if (aio_read(&cb) == -1) {
1010                 if (errno == EINVAL)
1011                         goto finished;
1012                 atf_tc_fail("aio_read() of too large read size failed: %s",
1013                     strerror(errno));
1014         }
1015
1016         nread = aio_waitcomplete(&cbp, NULL);
1017         if (nread == -1) {
1018                 if (errno == EINVAL)
1019                         goto finished;
1020                 atf_tc_fail("aio_waitcomplete() failed: %s", strerror(errno));
1021         }
1022         atf_tc_fail("aio_read() of too large read size returned: %zd", nread);
1023
1024 finished:
1025         close(fd);
1026 }
1027
1028 /*
1029  * This tests for a bug where arriving socket data can wakeup multiple
1030  * AIO read requests resulting in an uncancellable request.
1031  */
1032 ATF_TC_WITHOUT_HEAD(aio_socket_two_reads);
1033 ATF_TC_BODY(aio_socket_two_reads, tc)
1034 {
1035         struct ioreq {
1036                 struct aiocb iocb;
1037                 char buffer[1024];
1038         } ioreq[2];
1039         struct aiocb *iocb;
1040         unsigned i;
1041         int s[2];
1042         char c;
1043
1044         ATF_REQUIRE_KERNEL_MODULE("aio");
1045 #if __FreeBSD_version < 1100101
1046         aft_tc_skip("kernel version %d is too old (%d required)",
1047             __FreeBSD_version, 1100101);
1048 #endif
1049
1050         ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1051
1052         /* Queue two read requests. */
1053         memset(&ioreq, 0, sizeof(ioreq));
1054         for (i = 0; i < nitems(ioreq); i++) {
1055                 ioreq[i].iocb.aio_nbytes = sizeof(ioreq[i].buffer);
1056                 ioreq[i].iocb.aio_fildes = s[0];
1057                 ioreq[i].iocb.aio_buf = ioreq[i].buffer;
1058                 ATF_REQUIRE(aio_read(&ioreq[i].iocb) == 0);
1059         }
1060
1061         /* Send a single byte.  This should complete one request. */
1062         c = 0xc3;
1063         ATF_REQUIRE(write(s[1], &c, sizeof(c)) == 1);
1064
1065         ATF_REQUIRE(aio_waitcomplete(&iocb, NULL) == 1);
1066
1067         /* Determine which request completed and verify the data was read. */
1068         if (iocb == &ioreq[0].iocb)
1069                 i = 0;
1070         else
1071                 i = 1;
1072         ATF_REQUIRE(ioreq[i].buffer[0] == c);
1073
1074         i ^= 1;
1075
1076         /*
1077          * Try to cancel the other request.  On broken systems this
1078          * will fail and the process will hang on exit.
1079          */
1080         ATF_REQUIRE(aio_error(&ioreq[i].iocb) == EINPROGRESS);
1081         ATF_REQUIRE(aio_cancel(s[0], &ioreq[i].iocb) == AIO_CANCELED);
1082
1083         close(s[1]);
1084         close(s[0]);
1085 }
1086
1087 static void
1088 aio_socket_blocking_short_write_test(bool vectored)
1089 {
1090         struct aiocb iocb, *iocbp;
1091         struct iovec iov[2];
1092         char *buffer[2];
1093         ssize_t done, r;
1094         int buffer_size, sb_size;
1095         socklen_t len;
1096         int s[2];
1097
1098         ATF_REQUIRE_KERNEL_MODULE("aio");
1099
1100         ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1101
1102         len = sizeof(sb_size);
1103         ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1104             -1);
1105         ATF_REQUIRE(len == sizeof(sb_size));
1106         buffer_size = sb_size;
1107
1108         ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1109             -1);
1110         ATF_REQUIRE(len == sizeof(sb_size));
1111         if (sb_size > buffer_size)
1112                 buffer_size = sb_size;
1113
1114         /*
1115          * Use twice the size of the MAX(receive buffer, send buffer)
1116          * to ensure that the write is split up into multiple writes
1117          * internally.
1118          */
1119         buffer_size *= 2;
1120
1121         buffer[0] = malloc(buffer_size);
1122         ATF_REQUIRE(buffer[0] != NULL);
1123         buffer[1] = malloc(buffer_size);
1124         ATF_REQUIRE(buffer[1] != NULL);
1125
1126         srandomdev();
1127         aio_fill_buffer(buffer[1], buffer_size, random());
1128
1129         memset(&iocb, 0, sizeof(iocb));
1130         iocb.aio_fildes = s[1];
1131         if (vectored) {
1132                 iov[0].iov_base = buffer[1];
1133                 iov[0].iov_len = buffer_size / 2 + 1;
1134                 iov[1].iov_base = buffer[1] + buffer_size / 2 + 1;
1135                 iov[1].iov_len = buffer_size / 2 - 1;
1136                 iocb.aio_iov = iov;
1137                 iocb.aio_iovcnt = 2;
1138                 r = aio_writev(&iocb);
1139                 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1140         } else {
1141                 iocb.aio_buf = buffer[1];
1142                 iocb.aio_nbytes = buffer_size;
1143                 r = aio_write(&iocb);
1144                 ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1145         }
1146
1147         done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1148         ATF_REQUIRE(done == buffer_size);
1149
1150         done = aio_waitcomplete(&iocbp, NULL);
1151         ATF_REQUIRE(iocbp == &iocb);
1152         ATF_REQUIRE(done == buffer_size);
1153
1154         ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1155
1156         close(s[1]);
1157         close(s[0]);
1158 }
1159
1160 /*
1161  * This test ensures that aio_write() on a blocking socket of a "large"
1162  * buffer does not return a short completion.
1163  */
1164 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write);
1165 ATF_TC_BODY(aio_socket_blocking_short_write, tc)
1166 {
1167         aio_socket_blocking_short_write_test(false);
1168 }
1169
1170 /*
1171  * Like aio_socket_blocking_short_write, but also tests that partially
1172  * completed vectored sends can be retried correctly.
1173  */
1174 ATF_TC_WITHOUT_HEAD(aio_socket_blocking_short_write_vectored);
1175 ATF_TC_BODY(aio_socket_blocking_short_write_vectored, tc)
1176 {
1177         aio_socket_blocking_short_write_test(true);
1178 }
1179
1180 /*
1181  * This test verifies that cancelling a partially completed socket write
1182  * returns a short write rather than ECANCELED.
1183  */
1184 ATF_TC_WITHOUT_HEAD(aio_socket_short_write_cancel);
1185 ATF_TC_BODY(aio_socket_short_write_cancel, tc)
1186 {
1187         struct aiocb iocb, *iocbp;
1188         char *buffer[2];
1189         ssize_t done;
1190         int buffer_size, sb_size;
1191         socklen_t len;
1192         int s[2];
1193
1194         ATF_REQUIRE_KERNEL_MODULE("aio");
1195
1196         ATF_REQUIRE(socketpair(PF_UNIX, SOCK_STREAM, 0, s) != -1);
1197
1198         len = sizeof(sb_size);
1199         ATF_REQUIRE(getsockopt(s[0], SOL_SOCKET, SO_RCVBUF, &sb_size, &len) !=
1200             -1);
1201         ATF_REQUIRE(len == sizeof(sb_size));
1202         buffer_size = sb_size;
1203
1204         ATF_REQUIRE(getsockopt(s[1], SOL_SOCKET, SO_SNDBUF, &sb_size, &len) !=
1205             -1);
1206         ATF_REQUIRE(len == sizeof(sb_size));
1207         if (sb_size > buffer_size)
1208                 buffer_size = sb_size;
1209
1210         /*
1211          * Use three times the size of the MAX(receive buffer, send
1212          * buffer) for the write to ensure that the write is split up
1213          * into multiple writes internally.  The recv() ensures that
1214          * the write has partially completed, but a remaining size of
1215          * two buffers should ensure that the write has not completed
1216          * fully when it is cancelled.
1217          */
1218         buffer[0] = malloc(buffer_size);
1219         ATF_REQUIRE(buffer[0] != NULL);
1220         buffer[1] = malloc(buffer_size * 3);
1221         ATF_REQUIRE(buffer[1] != NULL);
1222
1223         srandomdev();
1224         aio_fill_buffer(buffer[1], buffer_size * 3, random());
1225
1226         memset(&iocb, 0, sizeof(iocb));
1227         iocb.aio_fildes = s[1];
1228         iocb.aio_buf = buffer[1];
1229         iocb.aio_nbytes = buffer_size * 3;
1230         ATF_REQUIRE(aio_write(&iocb) == 0);
1231
1232         done = recv(s[0], buffer[0], buffer_size, MSG_WAITALL);
1233         ATF_REQUIRE(done == buffer_size);
1234
1235         ATF_REQUIRE(aio_error(&iocb) == EINPROGRESS);
1236         ATF_REQUIRE(aio_cancel(s[1], &iocb) == AIO_NOTCANCELED);
1237
1238         done = aio_waitcomplete(&iocbp, NULL);
1239         ATF_REQUIRE(iocbp == &iocb);
1240         ATF_REQUIRE(done >= buffer_size && done <= buffer_size * 2);
1241
1242         ATF_REQUIRE(memcmp(buffer[0], buffer[1], buffer_size) == 0);
1243
1244         close(s[1]);
1245         close(s[0]);
1246 }
1247
1248 /*
1249  * test aio_fsync's behavior with bad inputs
1250  */
1251 ATF_TC_WITHOUT_HEAD(aio_fsync_errors);
1252 ATF_TC_BODY(aio_fsync_errors, tc)
1253 {
1254         int fd;
1255         struct aiocb iocb;
1256
1257         ATF_REQUIRE_KERNEL_MODULE("aio");
1258         ATF_REQUIRE_UNSAFE_AIO();
1259
1260         fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1261         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1262         unlink(FILE_PATHNAME);
1263
1264         /* aio_fsync should return EINVAL unless op is O_SYNC or O_DSYNC */
1265         memset(&iocb, 0, sizeof(iocb));
1266         iocb.aio_fildes = fd;
1267         ATF_CHECK_EQ(-1, aio_fsync(666, &iocb));
1268         ATF_CHECK_EQ(EINVAL, errno);
1269
1270         /* aio_fsync should return EBADF if fd is not a valid descriptor */
1271         memset(&iocb, 0, sizeof(iocb));
1272         iocb.aio_fildes = 666;
1273         ATF_CHECK_EQ(-1, aio_fsync(O_SYNC, &iocb));
1274         ATF_CHECK_EQ(EBADF, errno);
1275
1276         /* aio_fsync should return EINVAL if sigev_notify is invalid */
1277         memset(&iocb, 0, sizeof(iocb));
1278         iocb.aio_fildes = fd;
1279         iocb.aio_sigevent.sigev_notify = 666;
1280         ATF_CHECK_EQ(-1, aio_fsync(666, &iocb));
1281         ATF_CHECK_EQ(EINVAL, errno);
1282 }
1283
1284 /*
1285  * This test just performs a basic test of aio_fsync().
1286  */
1287 static void
1288 aio_fsync_test(int op)
1289 {
1290         struct aiocb synccb, *iocbp;
1291         struct {
1292                 struct aiocb iocb;
1293                 bool done;
1294                 char *buffer;
1295         } buffers[16];
1296         struct stat sb;
1297         ssize_t rval;
1298         unsigned i;
1299         int fd;
1300
1301         ATF_REQUIRE_KERNEL_MODULE("aio");
1302         ATF_REQUIRE_UNSAFE_AIO();
1303
1304         fd = open(FILE_PATHNAME, O_RDWR | O_CREAT, 0600);
1305         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1306         unlink(FILE_PATHNAME);
1307
1308         ATF_REQUIRE(fstat(fd, &sb) == 0);
1309         ATF_REQUIRE(sb.st_blksize != 0);
1310         ATF_REQUIRE(ftruncate(fd, sb.st_blksize * nitems(buffers)) == 0);
1311
1312         /*
1313          * Queue several asynchronous write requests.  Hopefully this
1314          * forces the aio_fsync() request to be deferred.  There is no
1315          * reliable way to guarantee that however.
1316          */
1317         srandomdev();
1318         for (i = 0; i < nitems(buffers); i++) {
1319                 buffers[i].done = false;
1320                 memset(&buffers[i].iocb, 0, sizeof(buffers[i].iocb));
1321                 buffers[i].buffer = malloc(sb.st_blksize);
1322                 aio_fill_buffer(buffers[i].buffer, sb.st_blksize, random());
1323                 buffers[i].iocb.aio_fildes = fd;
1324                 buffers[i].iocb.aio_buf = buffers[i].buffer;
1325                 buffers[i].iocb.aio_nbytes = sb.st_blksize;
1326                 buffers[i].iocb.aio_offset = sb.st_blksize * i;
1327                 ATF_REQUIRE(aio_write(&buffers[i].iocb) == 0);
1328         }
1329
1330         /* Queue the aio_fsync request. */
1331         memset(&synccb, 0, sizeof(synccb));
1332         synccb.aio_fildes = fd;
1333         ATF_REQUIRE(aio_fsync(op, &synccb) == 0);
1334
1335         /* Wait for requests to complete. */
1336         for (;;) {
1337         next:
1338                 rval = aio_waitcomplete(&iocbp, NULL);
1339                 ATF_REQUIRE(iocbp != NULL);
1340                 if (iocbp == &synccb) {
1341                         ATF_REQUIRE(rval == 0);
1342                         break;
1343                 }
1344
1345                 for (i = 0; i < nitems(buffers); i++) {
1346                         if (iocbp == &buffers[i].iocb) {
1347                                 ATF_REQUIRE(buffers[i].done == false);
1348                                 ATF_REQUIRE(rval == sb.st_blksize);
1349                                 buffers[i].done = true;
1350                                 goto next;
1351                         }
1352                 }
1353
1354                 ATF_REQUIRE_MSG(false, "unmatched AIO request");
1355         }
1356
1357         for (i = 0; i < nitems(buffers); i++)
1358                 ATF_REQUIRE_MSG(buffers[i].done,
1359                     "AIO request %u did not complete", i);
1360
1361         close(fd);
1362 }
1363
1364 ATF_TC_WITHOUT_HEAD(aio_fsync_sync_test);
1365 ATF_TC_BODY(aio_fsync_sync_test, tc)
1366 {
1367         aio_fsync_test(O_SYNC);
1368 }
1369
1370 ATF_TC_WITHOUT_HEAD(aio_fsync_dsync_test);
1371 ATF_TC_BODY(aio_fsync_dsync_test, tc)
1372 {
1373         aio_fsync_test(O_DSYNC);
1374 }
1375
1376 /*
1377  * We shouldn't be able to DoS the system by setting iov_len to an insane
1378  * value
1379  */
1380 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iov_len);
1381 ATF_TC_BODY(aio_writev_dos_iov_len, tc)
1382 {
1383         struct aiocb aio;
1384         const struct aiocb *const iocbs[] = {&aio};
1385         const char *wbuf = "Hello, world!";
1386         struct iovec iov[1];
1387         ssize_t len, r;
1388         int fd;
1389
1390         ATF_REQUIRE_KERNEL_MODULE("aio");
1391         ATF_REQUIRE_UNSAFE_AIO();
1392
1393         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1394         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1395
1396         len = strlen(wbuf);
1397         iov[0].iov_base = __DECONST(void*, wbuf);
1398         iov[0].iov_len = 1 << 30;
1399         bzero(&aio, sizeof(aio));
1400         aio.aio_fildes = fd;
1401         aio.aio_offset = 0;
1402         aio.aio_iov = iov;
1403         aio.aio_iovcnt = 1;
1404
1405         r = aio_writev(&aio);
1406         ATF_CHECK_EQ_MSG(0, r, "aio_writev returned %zd", r);
1407         ATF_REQUIRE_EQ(0, aio_suspend(iocbs, 1, NULL));
1408         r = aio_return(&aio);
1409         ATF_CHECK_EQ_MSG(-1, r, "aio_return returned %zd", r);
1410         ATF_CHECK_MSG(errno == EFAULT || errno == EINVAL,
1411             "aio_writev: %s", strerror(errno));
1412
1413         close(fd);
1414 }
1415
1416 /*
1417  * We shouldn't be able to DoS the system by setting aio_iovcnt to an insane
1418  * value
1419  */
1420 ATF_TC_WITHOUT_HEAD(aio_writev_dos_iovcnt);
1421 ATF_TC_BODY(aio_writev_dos_iovcnt, tc)
1422 {
1423         struct aiocb aio;
1424         const char *wbuf = "Hello, world!";
1425         struct iovec iov[1];
1426         ssize_t len;
1427         int fd;
1428
1429         ATF_REQUIRE_KERNEL_MODULE("aio");
1430         ATF_REQUIRE_UNSAFE_AIO();
1431
1432         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1433         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1434
1435         len = strlen(wbuf);
1436         iov[0].iov_base = __DECONST(void*, wbuf);
1437         iov[0].iov_len = len;
1438         bzero(&aio, sizeof(aio));
1439         aio.aio_fildes = fd;
1440         aio.aio_offset = 0;
1441         aio.aio_iov = iov;
1442         aio.aio_iovcnt = 1 << 30;
1443
1444         ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1445         ATF_CHECK_EQ(EINVAL, errno);
1446
1447         close(fd);
1448 }
1449
1450 ATF_TC_WITH_CLEANUP(aio_writev_efault);
1451 ATF_TC_HEAD(aio_writev_efault, tc)
1452 {
1453         atf_tc_set_md_var(tc, "descr",
1454             "Vectored AIO should gracefully handle invalid addresses");
1455         atf_tc_set_md_var(tc, "require.user", "root");
1456 }
1457 ATF_TC_BODY(aio_writev_efault, tc)
1458 {
1459         struct aiocb aio;
1460         ssize_t buflen;
1461         char *buffer;
1462         struct iovec iov[2];
1463         long seed;
1464         int fd;
1465
1466         ATF_REQUIRE_KERNEL_MODULE("aio");
1467         ATF_REQUIRE_UNSAFE_AIO();
1468
1469         fd = aio_md_setup();
1470
1471         seed = random();
1472         buflen = 4096;
1473         buffer = malloc(buflen);
1474         aio_fill_buffer(buffer, buflen, seed);
1475         iov[0].iov_base = buffer;
1476         iov[0].iov_len = buflen;
1477         iov[1].iov_base = (void*)-1;    /* Invalid! */
1478         iov[1].iov_len = buflen;
1479         bzero(&aio, sizeof(aio));
1480         aio.aio_fildes = fd;
1481         aio.aio_offset = 0;
1482         aio.aio_iov = iov;
1483         aio.aio_iovcnt = nitems(iov);
1484
1485         ATF_REQUIRE_EQ(-1, aio_writev(&aio));
1486         ATF_CHECK_EQ(EFAULT, errno);
1487
1488         close(fd);
1489 }
1490 ATF_TC_CLEANUP(aio_writev_efault, tc)
1491 {
1492         aio_md_cleanup();
1493 }
1494
1495 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_poll);
1496 ATF_TC_BODY(aio_writev_empty_file_poll, tc)
1497 {
1498         struct aiocb aio;
1499         int fd;
1500
1501         ATF_REQUIRE_KERNEL_MODULE("aio");
1502         ATF_REQUIRE_UNSAFE_AIO();
1503
1504         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1505         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1506
1507         bzero(&aio, sizeof(aio));
1508         aio.aio_fildes = fd;
1509         aio.aio_offset = 0;
1510         aio.aio_iovcnt = 0;
1511
1512         ATF_REQUIRE_EQ(0, aio_writev(&aio));
1513         ATF_REQUIRE_EQ(0, suspend(&aio));
1514
1515         close(fd);
1516 }
1517
1518 ATF_TC_WITHOUT_HEAD(aio_writev_empty_file_signal);
1519 ATF_TC_BODY(aio_writev_empty_file_signal, tc)
1520 {
1521         struct aiocb aio;
1522         int fd;
1523
1524         ATF_REQUIRE_KERNEL_MODULE("aio");
1525         ATF_REQUIRE_UNSAFE_AIO();
1526
1527         fd = open("testfile", O_RDWR | O_CREAT, 0600);
1528         ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno));
1529
1530         bzero(&aio, sizeof(aio));
1531         aio.aio_fildes = fd;
1532         aio.aio_offset = 0;
1533         aio.aio_iovcnt = 0;
1534         aio.aio_sigevent = *setup_signal();
1535
1536         ATF_REQUIRE_EQ(0, aio_writev(&aio));
1537         ATF_REQUIRE_EQ(0, poll_signaled(&aio));
1538
1539         close(fd);
1540 }
1541
1542 // aio_writev and aio_readv should still work even if the iovcnt is greater
1543 // than the number of buffered AIO operations permitted per process.
1544 ATF_TC_WITH_CLEANUP(vectored_big_iovcnt);
1545 ATF_TC_HEAD(vectored_big_iovcnt, tc)
1546 {
1547         atf_tc_set_md_var(tc, "descr",
1548             "Vectored AIO should still work even if the iovcnt is greater than "
1549             "the number of buffered AIO operations permitted by the process");
1550         atf_tc_set_md_var(tc, "require.user", "root");
1551 }
1552 ATF_TC_BODY(vectored_big_iovcnt, tc)
1553 {
1554         struct aiocb aio;
1555         struct iovec *iov;
1556         ssize_t len, buflen;
1557         char *buffer;
1558         const char *oid = "vfs.aio.max_buf_aio";
1559         long seed;
1560         int max_buf_aio;
1561         int fd, i;
1562         ssize_t sysctl_len = sizeof(max_buf_aio);
1563
1564         ATF_REQUIRE_KERNEL_MODULE("aio");
1565         ATF_REQUIRE_UNSAFE_AIO();
1566
1567         if (sysctlbyname(oid, &max_buf_aio, &sysctl_len, NULL, 0) == -1)
1568                 atf_libc_error(errno, "Failed to read %s", oid);
1569
1570         seed = random();
1571         buflen = 512 * (max_buf_aio + 1);
1572         buffer = malloc(buflen);
1573         aio_fill_buffer(buffer, buflen, seed);
1574         iov = calloc(max_buf_aio + 1, sizeof(struct iovec));
1575
1576         fd = aio_md_setup();
1577
1578         bzero(&aio, sizeof(aio));
1579         aio.aio_fildes = fd;
1580         aio.aio_offset = 0;
1581         for (i = 0; i < max_buf_aio + 1; i++) {
1582                 iov[i].iov_base = &buffer[i * 512];
1583                 iov[i].iov_len = 512;
1584         }
1585         aio.aio_iov = iov;
1586         aio.aio_iovcnt = max_buf_aio + 1;
1587
1588         if (aio_writev(&aio) < 0)
1589                 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1590
1591         len = poll(&aio);
1592         if (len < 0)
1593                 atf_tc_fail("aio failed: %s", strerror(errno));
1594
1595         if (len != buflen)
1596                 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
1597
1598         bzero(&aio, sizeof(aio));
1599         aio.aio_fildes = fd;
1600         aio.aio_offset = 0;
1601         aio.aio_iov = iov;
1602         aio.aio_iovcnt = max_buf_aio + 1;
1603
1604         if (aio_readv(&aio) < 0)
1605                 atf_tc_fail("aio_readv failed: %s", strerror(errno));
1606
1607         len = poll(&aio);
1608         if (len < 0)
1609                 atf_tc_fail("aio failed: %s", strerror(errno));
1610
1611         if (len != buflen)
1612                 atf_tc_fail("aio short read (%jd)", (intmax_t)len);
1613
1614         if (aio_test_buffer(buffer, buflen, seed) == 0)
1615                 atf_tc_fail("buffer mismatched");
1616
1617         close(fd);
1618 }
1619 ATF_TC_CLEANUP(vectored_big_iovcnt, tc)
1620 {
1621         aio_md_cleanup();
1622 }
1623
1624 ATF_TC_WITHOUT_HEAD(vectored_file_poll);
1625 ATF_TC_BODY(vectored_file_poll, tc)
1626 {
1627         aio_file_test(poll, NULL, true);
1628 }
1629
1630 ATF_TC_WITH_CLEANUP(vectored_md_poll);
1631 ATF_TC_HEAD(vectored_md_poll, tc)
1632 {
1633         atf_tc_set_md_var(tc, "require.user", "root");
1634 }
1635 ATF_TC_BODY(vectored_md_poll, tc)
1636 {
1637         aio_md_test(poll, NULL, true);
1638 }
1639 ATF_TC_CLEANUP(vectored_md_poll, tc)
1640 {
1641         aio_md_cleanup();
1642 }
1643
1644 ATF_TC_WITHOUT_HEAD(vectored_socket_poll);
1645 ATF_TC_BODY(vectored_socket_poll, tc)
1646 {
1647         aio_unix_socketpair_test(poll, NULL, true);
1648 }
1649
1650 // aio_writev and aio_readv should still work even if the iov contains elements
1651 // that aren't a multiple of the device's sector size, and even if the total
1652 // amount if I/O _is_ a multiple of the device's sector size.
1653 ATF_TC_WITH_CLEANUP(vectored_unaligned);
1654 ATF_TC_HEAD(vectored_unaligned, tc)
1655 {
1656         atf_tc_set_md_var(tc, "descr",
1657             "Vectored AIO should still work even if the iov contains elements "
1658             "that aren't a multiple of the sector size.");
1659         atf_tc_set_md_var(tc, "require.user", "root");
1660 }
1661 ATF_TC_BODY(vectored_unaligned, tc)
1662 {
1663         struct aio_context ac;
1664         struct aiocb aio;
1665         struct iovec iov[3];
1666         ssize_t len, total_len;
1667         int fd;
1668
1669         if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false))
1670                 atf_tc_skip("https://bugs.freebsd.org/258766");
1671
1672         ATF_REQUIRE_KERNEL_MODULE("aio");
1673         ATF_REQUIRE_UNSAFE_AIO();
1674
1675         /*
1676          * Use a zvol with volmode=dev, so it will allow .d_write with
1677          * unaligned uio.  geom devices use physio, which doesn't allow that.
1678          */
1679         fd = aio_zvol_setup();
1680         aio_context_init(&ac, fd, fd, FILE_LEN);
1681
1682         /* Break the buffer into 3 parts:
1683          * * A 4kB part, aligned to 4kB
1684          * * Two other parts that add up to 4kB:
1685          *   - 256B
1686          *   - 4kB - 256B
1687          */
1688         iov[0].iov_base = ac.ac_buffer;
1689         iov[0].iov_len = 4096;
1690         iov[1].iov_base = (void*)((uintptr_t)iov[0].iov_base + iov[0].iov_len);
1691         iov[1].iov_len = 256;
1692         iov[2].iov_base = (void*)((uintptr_t)iov[1].iov_base + iov[1].iov_len);
1693         iov[2].iov_len = 4096 - iov[1].iov_len;
1694         total_len = iov[0].iov_len + iov[1].iov_len + iov[2].iov_len;
1695         bzero(&aio, sizeof(aio));
1696         aio.aio_fildes = ac.ac_write_fd;
1697         aio.aio_offset = 0;
1698         aio.aio_iov = iov;
1699         aio.aio_iovcnt = 3;
1700
1701         if (aio_writev(&aio) < 0)
1702                 atf_tc_fail("aio_writev failed: %s", strerror(errno));
1703
1704         len = poll(&aio);
1705         if (len < 0)
1706                 atf_tc_fail("aio failed: %s", strerror(errno));
1707
1708         if (len != total_len)
1709                 atf_tc_fail("aio short write (%jd)", (intmax_t)len);
1710
1711         bzero(&aio, sizeof(aio));
1712         aio.aio_fildes = ac.ac_read_fd;
1713         aio.aio_offset = 0;
1714         aio.aio_iov = iov;
1715         aio.aio_iovcnt = 3;
1716
1717         if (aio_readv(&aio) < 0)
1718                 atf_tc_fail("aio_readv failed: %s", strerror(errno));
1719         len = poll(&aio);
1720
1721         ATF_REQUIRE_MSG(aio_test_buffer(ac.ac_buffer, total_len,
1722             ac.ac_seed) != 0, "aio_test_buffer: internal error");
1723
1724         close(fd);
1725 }
1726 ATF_TC_CLEANUP(vectored_unaligned, tc)
1727 {
1728         aio_zvol_cleanup();
1729 }
1730
1731 static void
1732 aio_zvol_test(completion comp, struct sigevent *sev, bool vectored)
1733 {
1734         struct aio_context ac;
1735         int fd;
1736
1737         fd = aio_zvol_setup();
1738         aio_context_init(&ac, fd, fd, MD_LEN);
1739         if (vectored) {
1740                 aio_writev_test(&ac, comp, sev);
1741                 aio_readv_test(&ac, comp, sev);
1742         } else {
1743                 aio_write_test(&ac, comp, sev);
1744                 aio_read_test(&ac, comp, sev);
1745         }
1746
1747         close(fd);
1748 }
1749
1750 /*
1751  * Note that unlike md, the zvol is not a geom device, does not allow unmapped
1752  * buffers, and does not use physio.
1753  */
1754 ATF_TC_WITH_CLEANUP(vectored_zvol_poll);
1755 ATF_TC_HEAD(vectored_zvol_poll, tc)
1756 {
1757         atf_tc_set_md_var(tc, "require.user", "root");
1758 }
1759 ATF_TC_BODY(vectored_zvol_poll, tc)
1760 {
1761         if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false))
1762                 atf_tc_skip("https://bugs.freebsd.org/258766");
1763         aio_zvol_test(poll, NULL, true);
1764 }
1765 ATF_TC_CLEANUP(vectored_zvol_poll, tc)
1766 {
1767         aio_zvol_cleanup();
1768 }
1769
1770 ATF_TP_ADD_TCS(tp)
1771 {
1772
1773         ATF_TP_ADD_TC(tp, file_poll);
1774         ATF_TP_ADD_TC(tp, file_signal);
1775         ATF_TP_ADD_TC(tp, file_suspend);
1776         ATF_TP_ADD_TC(tp, file_thread);
1777         ATF_TP_ADD_TC(tp, file_waitcomplete);
1778         ATF_TP_ADD_TC(tp, fifo_poll);
1779         ATF_TP_ADD_TC(tp, fifo_signal);
1780         ATF_TP_ADD_TC(tp, fifo_suspend);
1781         ATF_TP_ADD_TC(tp, fifo_thread);
1782         ATF_TP_ADD_TC(tp, fifo_waitcomplete);
1783         ATF_TP_ADD_TC(tp, socket_poll);
1784         ATF_TP_ADD_TC(tp, socket_signal);
1785         ATF_TP_ADD_TC(tp, socket_suspend);
1786         ATF_TP_ADD_TC(tp, socket_thread);
1787         ATF_TP_ADD_TC(tp, socket_waitcomplete);
1788         ATF_TP_ADD_TC(tp, pty_poll);
1789         ATF_TP_ADD_TC(tp, pty_signal);
1790         ATF_TP_ADD_TC(tp, pty_suspend);
1791         ATF_TP_ADD_TC(tp, pty_thread);
1792         ATF_TP_ADD_TC(tp, pty_waitcomplete);
1793         ATF_TP_ADD_TC(tp, pipe_poll);
1794         ATF_TP_ADD_TC(tp, pipe_signal);
1795         ATF_TP_ADD_TC(tp, pipe_suspend);
1796         ATF_TP_ADD_TC(tp, pipe_thread);
1797         ATF_TP_ADD_TC(tp, pipe_waitcomplete);
1798         ATF_TP_ADD_TC(tp, md_poll);
1799         ATF_TP_ADD_TC(tp, md_signal);
1800         ATF_TP_ADD_TC(tp, md_suspend);
1801         ATF_TP_ADD_TC(tp, md_thread);
1802         ATF_TP_ADD_TC(tp, md_waitcomplete);
1803         ATF_TP_ADD_TC(tp, aio_fsync_errors);
1804         ATF_TP_ADD_TC(tp, aio_fsync_sync_test);
1805         ATF_TP_ADD_TC(tp, aio_fsync_dsync_test);
1806         ATF_TP_ADD_TC(tp, aio_large_read_test);
1807         ATF_TP_ADD_TC(tp, aio_socket_two_reads);
1808         ATF_TP_ADD_TC(tp, aio_socket_blocking_short_write);
1809         ATF_TP_ADD_TC(tp, aio_socket_blocking_short_write_vectored);
1810         ATF_TP_ADD_TC(tp, aio_socket_short_write_cancel);
1811         ATF_TP_ADD_TC(tp, aio_writev_dos_iov_len);
1812         ATF_TP_ADD_TC(tp, aio_writev_dos_iovcnt);
1813         ATF_TP_ADD_TC(tp, aio_writev_efault);
1814         ATF_TP_ADD_TC(tp, aio_writev_empty_file_poll);
1815         ATF_TP_ADD_TC(tp, aio_writev_empty_file_signal);
1816         ATF_TP_ADD_TC(tp, vectored_big_iovcnt);
1817         ATF_TP_ADD_TC(tp, vectored_file_poll);
1818         ATF_TP_ADD_TC(tp, vectored_md_poll);
1819         ATF_TP_ADD_TC(tp, vectored_zvol_poll);
1820         ATF_TP_ADD_TC(tp, vectored_unaligned);
1821         ATF_TP_ADD_TC(tp, vectored_socket_poll);
1822
1823         return (atf_no_error());
1824 }