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