1 /* $NetBSD: t_poll.c,v 1.12 2025/02/10 02:41:34 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2011 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Matthias Scheler. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/ioctl.h> 33 #include <sys/socket.h> 34 #include <sys/stat.h> 35 #include <sys/time.h> 36 #include <sys/wait.h> 37 38 #include <atf-c.h> 39 #include <errno.h> 40 #include <fcntl.h> 41 #include <paths.h> 42 #include <poll.h> 43 #include <pthread.h> 44 #include <stdio.h> 45 #include <stdlib.h> 46 #include <signal.h> 47 #include <termios.h> 48 #include <unistd.h> 49 50 #include "h_macros.h" 51 52 static int desc; 53 54 static void 55 child1(void) 56 { 57 struct pollfd pfd; 58 59 pfd.fd = desc; 60 pfd.events = POLLIN | POLLHUP | POLLOUT; 61 62 (void)poll(&pfd, 1, 2000); 63 (void)printf("child1 exit\n"); 64 } 65 66 static void 67 child2(void) 68 { 69 struct pollfd pfd; 70 71 pfd.fd = desc; 72 pfd.events = POLLIN | POLLHUP | POLLOUT; 73 74 (void)sleep(1); 75 (void)poll(&pfd, 1, INFTIM); 76 (void)printf("child2 exit\n"); 77 } 78 79 static void 80 child3(void) 81 { 82 struct pollfd pfd; 83 84 (void)sleep(5); 85 86 pfd.fd = desc; 87 pfd.events = POLLIN | POLLHUP | POLLOUT; 88 89 (void)poll(&pfd, 1, INFTIM); 90 (void)printf("child3 exit\n"); 91 } 92 93 ATF_TC(3way); 94 ATF_TC_HEAD(3way, tc) 95 { 96 atf_tc_set_md_var(tc, "timeout", "15"); 97 atf_tc_set_md_var(tc, "descr", 98 "Check for 3-way collision for descriptor. First child comes " 99 "and polls on descriptor, second child comes and polls, first " 100 "child times out and exits, third child comes and polls. When " 101 "the wakeup event happens, the two remaining children should " 102 "both be awaken. (kern/17517)"); 103 } 104 105 ATF_TC_BODY(3way, tc) 106 { 107 int pf[2]; 108 int status, i; 109 pid_t pid; 110 ssize_t nwrit; 111 112 RL(pipe(pf)); 113 desc = pf[0]; 114 115 RL(pid = fork()); 116 if (pid == 0) { 117 if (close(pf[1]) == -1) 118 _exit(1); 119 child1(); 120 _exit(0); 121 /* NOTREACHED */ 122 } 123 124 RL(pid = fork()); 125 if (pid == 0) { 126 if (close(pf[1]) == -1) 127 _exit(1); 128 child2(); 129 _exit(0); 130 /* NOTREACHED */ 131 } 132 133 RL(pid = fork()); 134 if (pid == 0) { 135 if (close(pf[1]) == -1) 136 _exit(1); 137 child3(); 138 _exit(0); 139 /* NOTREACHED */ 140 } 141 142 (void)sleep(10); 143 144 (void)printf("parent write\n"); 145 146 RL(nwrit = write(pf[1], "konec\n", 6)); 147 ATF_REQUIRE_EQ_MSG(nwrit, 6, "nwrit=%zd", nwrit); 148 149 for (i = 0; i < 3; i++) 150 RL(wait(&status)); 151 152 (void)printf("parent terminated\n"); 153 } 154 155 ATF_TC(basic); 156 ATF_TC_HEAD(basic, tc) 157 { 158 atf_tc_set_md_var(tc, "timeout", "10"); 159 atf_tc_set_md_var(tc, "descr", 160 "Basis functionality test for poll(2)"); 161 } 162 163 ATF_TC_BODY(basic, tc) 164 { 165 int fds[2]; 166 struct pollfd pfds[2]; 167 int ret; 168 ssize_t nwrit; 169 170 RL(pipe(fds)); 171 172 pfds[0].fd = fds[0]; 173 pfds[0].events = POLLIN; 174 pfds[1].fd = fds[1]; 175 pfds[1].events = POLLOUT; 176 177 /* 178 * Check that we get a timeout waiting for data on the read end 179 * of our pipe. 180 */ 181 pfds[0].revents = -1; 182 pfds[1].revents = -1; 183 RL(ret = poll(&pfds[0], 1, 1)); 184 ATF_REQUIRE_EQ_MSG(ret, 0, "got: %d", ret); 185 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents); 186 ATF_REQUIRE_EQ_MSG(pfds[1].revents, -1, "got: %d", pfds[1].revents); 187 188 /* Check that the write end of the pipe as reported as ready. */ 189 pfds[0].revents = -1; 190 pfds[1].revents = -1; 191 RL(ret = poll(&pfds[1], 1, 1)); 192 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 193 ATF_REQUIRE_EQ_MSG(pfds[0].revents, -1, "got: %d", pfds[0].revents); 194 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",\ 195 pfds[1].revents); 196 197 /* Check that only the write end of the pipe as reported as ready. */ 198 pfds[0].revents = -1; 199 pfds[1].revents = -1; 200 RL(ret = poll(pfds, 2, 1)); 201 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 202 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents); 203 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d", 204 pfds[1].revents); 205 206 /* Write data to our pipe. */ 207 RL(nwrit = write(fds[1], "", 1)); 208 ATF_REQUIRE_EQ_MSG(nwrit, 1, "nwrit=%zd", nwrit); 209 210 /* Check that both ends of our pipe are reported as ready. */ 211 pfds[0].revents = -1; 212 pfds[1].revents = -1; 213 RL(ret = poll(pfds, 2, 1)); 214 ATF_REQUIRE_EQ_MSG(ret, 2, "got: %d", ret); 215 ATF_REQUIRE_EQ_MSG(pfds[0].revents, POLLIN, "got: %d", 216 pfds[0].revents); 217 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d", 218 pfds[1].revents); 219 220 RL(close(fds[0])); 221 RL(close(fds[1])); 222 } 223 224 ATF_TC(err); 225 ATF_TC_HEAD(err, tc) 226 { 227 atf_tc_set_md_var(tc, "descr", "Check errors from poll(2)"); 228 } 229 230 ATF_TC_BODY(err, tc) 231 { 232 struct pollfd pfd; 233 int fd = 0; 234 235 pfd.fd = fd; 236 pfd.events = POLLIN; 237 238 errno = 0; 239 ATF_REQUIRE_ERRNO(EFAULT, poll((struct pollfd *)-1, 1, -1) == -1); 240 241 errno = 0; 242 ATF_REQUIRE_ERRNO(EINVAL, poll(&pfd, 1, -2) == -1); 243 } 244 245 static const char fifo_path[] = "pollhup_fifo"; 246 247 static void 248 fifo_support(void) 249 { 250 251 errno = 0; 252 if (mkfifo(fifo_path, 0600) == 0) { 253 RL(unlink(fifo_path)); 254 return; 255 } 256 257 if (errno == EOPNOTSUPP) { 258 atf_tc_skip("the kernel does not support FIFOs"); 259 } else { 260 atf_tc_fail("mkfifo(2) failed"); 261 } 262 } 263 264 ATF_TC_WITH_CLEANUP(fifo_inout); 265 ATF_TC_HEAD(fifo_inout, tc) 266 { 267 atf_tc_set_md_var(tc, "descr", 268 "Check POLLIN/POLLOUT behavior with fifos"); 269 } 270 271 ATF_TC_BODY(fifo_inout, tc) 272 { 273 struct pollfd pfd[2]; 274 char *buf; 275 int rfd, wfd; 276 long pipe_buf; 277 int ret; 278 ssize_t nwrit, nread; 279 280 fifo_support(); 281 282 RL(mkfifo(fifo_path, 0600)); 283 RL(rfd = open(fifo_path, O_RDONLY | O_NONBLOCK)); 284 RL(wfd = open(fifo_path, O_WRONLY | O_NONBLOCK)); 285 286 /* Get the maximum atomic pipe write size. */ 287 pipe_buf = fpathconf(wfd, _PC_PIPE_BUF); 288 ATF_REQUIRE_MSG(pipe_buf > 1, "pipe_buf=%ld", pipe_buf); 289 290 REQUIRE_LIBC(buf = malloc(pipe_buf), NULL); 291 292 memset(&pfd, 0, sizeof(pfd)); 293 pfd[0].fd = rfd; 294 pfd[0].events = POLLIN | POLLRDNORM; 295 pfd[1].fd = wfd; 296 pfd[1].events = POLLOUT | POLLWRNORM; 297 298 /* We expect the FIFO to be writable but not readable. */ 299 RL(ret = poll(pfd, 2, 0)); 300 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 301 ATF_REQUIRE_EQ_MSG(pfd[0].revents, 0, 302 "pfd[0].revents=0x%x", pfd[0].revents); 303 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 304 "pfd[1].revents=0x%x", pfd[1].revents); 305 306 /* Write a single byte of data into the FIFO. */ 307 RL(nwrit = write(wfd, buf, 1)); 308 ATF_REQUIRE_EQ_MSG(nwrit, 1, "nwrit=%zd", nwrit); 309 310 /* We expect the FIFO to be readable and writable. */ 311 RL(ret = poll(pfd, 2, 0)); 312 ATF_REQUIRE_EQ_MSG(ret, 2, "got: %d", ret); 313 ATF_REQUIRE_EQ_MSG(pfd[0].revents, POLLIN|POLLRDNORM, 314 "pfd[0].revents=0x%x", pfd[0].revents); 315 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 316 "pfd[1].revents=0x%x", pfd[1].revents); 317 318 /* Read that single byte back out. */ 319 RL(nread = read(rfd, buf, 1)); 320 ATF_REQUIRE_EQ_MSG(nread, 1, "nread=%zd", nread); 321 322 /* 323 * Write data into the FIFO until it is full, which is 324 * defined as insufficient buffer space to hold a the 325 * maximum atomic pipe write size. 326 */ 327 while (write(wfd, buf, pipe_buf) != -1) { 328 continue; 329 } 330 ATF_REQUIRE_EQ_MSG(errno, EAGAIN, "errno=%d", errno); 331 332 /* We expect the FIFO to be readble but not writable. */ 333 RL(ret = poll(pfd, 2, 0)); 334 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 335 ATF_REQUIRE_EQ_MSG(pfd[0].revents, POLLIN|POLLRDNORM, 336 "pfd[0].revents=0x%x", pfd[0].revents); 337 ATF_REQUIRE_EQ_MSG(pfd[1].revents, 0, 338 "pfd[1].revents=0x%x", pfd[1].revents); 339 340 /* Read a single byte of data from the FIFO. */ 341 RL(nread = read(rfd, buf, 1)); 342 ATF_REQUIRE_EQ_MSG(nread, 1, "nread=%zd", nread); 343 344 /* 345 * Because we have read only a single byte out, there will 346 * be insufficient space for a pipe_buf-sized message, so 347 * the FIFO should still not be writable. 348 */ 349 RL(ret = poll(pfd, 2, 0)); 350 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 351 ATF_REQUIRE_EQ_MSG(pfd[0].revents, POLLIN|POLLRDNORM, 352 "pfd[0].revents=0x%x", pfd[0].revents); 353 ATF_REQUIRE_EQ_MSG(pfd[1].revents, 0, 354 "pfd[1].revents=0x%x", pfd[1].revents); 355 356 /* 357 * Now read enough so that exactly pipe_buf space should 358 * be available. The FIFO should be writable after that. 359 * N.B. we don't care if it's readable at this point. 360 */ 361 RL(nread = read(rfd, buf, pipe_buf - 1)); 362 ATF_REQUIRE_EQ_MSG(nread, pipe_buf - 1, "nread=%zd pipe_buf-1=%ld", 363 nread, pipe_buf - 1); 364 RL(ret = poll(pfd, 2, 0)); 365 ATF_REQUIRE_MSG(ret >= 1, "got: %d", ret); 366 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 367 "pfd[1].revents=0x%x", pfd[1].revents); 368 369 /* 370 * Now read all of the data out of the FIFO and ensure that 371 * we get back to the initial state. 372 */ 373 while (read(rfd, buf, pipe_buf) != -1) { 374 continue; 375 } 376 ATF_REQUIRE_EQ_MSG(errno, EAGAIN, "errno=%d", errno); 377 378 RL(ret = poll(pfd, 2, 0)); 379 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 380 ATF_REQUIRE_EQ_MSG(pfd[0].revents, 0, 381 "pfd[0].revents=0x%x", pfd[0].revents); 382 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 383 "pfd[1].revents=0x%x", pfd[1].revents); 384 385 RL(close(wfd)); 386 RL(close(rfd)); 387 } 388 389 ATF_TC_CLEANUP(fifo_inout, tc) 390 { 391 (void)unlink(fifo_path); 392 } 393 394 ATF_TC_WITH_CLEANUP(fifo_hup1); 395 ATF_TC_HEAD(fifo_hup1, tc) 396 { 397 atf_tc_set_md_var(tc, "descr", 398 "Check POLLHUP behavior with fifos [1]"); 399 } 400 401 ATF_TC_BODY(fifo_hup1, tc) 402 { 403 struct pollfd pfd; 404 int rfd, wfd; 405 int ret; 406 407 fifo_support(); 408 409 RL(mkfifo(fifo_path, 0600)); 410 RL(rfd = open(fifo_path, O_RDONLY | O_NONBLOCK)); 411 RL(wfd = open(fifo_path, O_WRONLY)); 412 413 memset(&pfd, 0, sizeof(pfd)); 414 pfd.fd = rfd; 415 pfd.events = POLLIN; 416 417 RL(close(wfd)); 418 419 RL(ret = poll(&pfd, 1, 0)); 420 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 421 ATF_REQUIRE_EQ_MSG((pfd.revents & (POLLHUP|POLLOUT)), POLLHUP, 422 "revents=0x%x expected POLLHUP=0x%x but not POLLOUT=0x%x", 423 pfd.revents, POLLHUP, POLLOUT); 424 425 /* 426 * Check that POLLHUP is cleared when a writer re-connects. 427 * Since the writer will not put any data into the FIFO, we 428 * expect no events. 429 */ 430 memset(&pfd, 0, sizeof(pfd)); 431 pfd.fd = rfd; 432 pfd.events = POLLIN; 433 434 RL(wfd = open(fifo_path, O_WRONLY)); 435 RL(ret = poll(&pfd, 1, 0)); 436 ATF_REQUIRE_EQ_MSG(ret, 0, "got: %d", ret); 437 } 438 439 ATF_TC_CLEANUP(fifo_hup1, tc) 440 { 441 (void)unlink(fifo_path); 442 } 443 444 ATF_TC_WITH_CLEANUP(fifo_hup2); 445 ATF_TC_HEAD(fifo_hup2, tc) 446 { 447 atf_tc_set_md_var(tc, "descr", 448 "Check POLLHUP behavior with fifos [2]"); 449 } 450 451 ATF_TC_BODY(fifo_hup2, tc) 452 { 453 struct pollfd pfd; 454 int rfd, wfd; 455 pid_t pid; 456 struct timespec ts1, ts2; 457 int ret; 458 459 fifo_support(); 460 461 RL(mkfifo(fifo_path, 0600)); 462 RL(rfd = open(fifo_path, O_RDONLY | O_NONBLOCK)); 463 RL(wfd = open(fifo_path, O_WRONLY)); 464 465 memset(&pfd, 0, sizeof(pfd)); 466 pfd.fd = rfd; 467 pfd.events = POLLIN; 468 469 RL(pid = fork()); 470 if (pid == 0) { 471 if (close(rfd)) 472 _exit(1); 473 sleep(5); 474 if (close(wfd)) 475 _exit(1); 476 _exit(0); 477 } 478 RL(close(wfd)); 479 480 RL(clock_gettime(CLOCK_MONOTONIC, &ts1)); 481 RL(ret = poll(&pfd, 1, INFTIM)); 482 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 483 RL(clock_gettime(CLOCK_MONOTONIC, &ts2)); 484 485 /* Make sure at least a couple of seconds have elapsed. */ 486 ATF_REQUIRE_MSG(ts2.tv_sec - ts1.tv_sec >= 2, 487 "ts1=%lld.%09ld ts2=%lld.%09ld", 488 (long long)ts1.tv_sec, ts1.tv_nsec, 489 (long long)ts2.tv_sec, ts2.tv_nsec); 490 491 ATF_REQUIRE_EQ_MSG((pfd.revents & (POLLHUP|POLLOUT)), POLLHUP, 492 "revents=0x%x expected POLLHUP=0x%x but not POLLOUT=0x%x", 493 pfd.revents, POLLHUP, POLLOUT); 494 } 495 496 ATF_TC_CLEANUP(fifo_hup2, tc) 497 { 498 (void)unlink(fifo_path); 499 } 500 501 static void 502 fillpipebuf(int writefd) 503 { 504 char buf[BUFSIZ] = {0}; 505 size_t n = 0; 506 ssize_t nwrit; 507 int flags; 508 509 RL(flags = fcntl(writefd, F_GETFL)); 510 RL(fcntl(writefd, F_SETFL, flags|O_NONBLOCK)); 511 while ((nwrit = write(writefd, buf, sizeof(buf))) != -1) 512 n += (size_t)nwrit; 513 ATF_CHECK_EQ_MSG(errno, EAGAIN, "errno=%d", errno); 514 RL(fcntl(writefd, F_SETFL, flags)); 515 fprintf(stderr, "filled %d with %zu bytes\n", writefd, n); 516 } 517 518 static void 519 check_write_fail(int writefd, int error) 520 { 521 int flags; 522 void (*sighandler)(int); 523 char c = 0; 524 ssize_t nwrit; 525 526 RL(flags = fcntl(writefd, F_GETFL)); 527 RL(fcntl(writefd, F_SETFL, flags|O_NONBLOCK)); 528 529 REQUIRE_LIBC(sighandler = signal(SIGPIPE, SIG_IGN), SIG_ERR); 530 ATF_CHECK_ERRNO(error, (nwrit = write(writefd, &c, 1)) == -1); 531 ATF_CHECK_EQ_MSG(nwrit, -1, "nwrit=%zd", nwrit); 532 REQUIRE_LIBC(signal(SIGPIPE, sighandler), SIG_ERR); 533 534 RL(fcntl(writefd, F_SETFL, flags)); 535 } 536 537 static void 538 check_read_eof(int readfd) 539 { 540 int flags; 541 char c; 542 ssize_t nread; 543 544 RL(flags = fcntl(readfd, F_GETFL)); 545 RL(fcntl(readfd, F_SETFL, flags|O_NONBLOCK)); 546 547 RL(nread = read(readfd, &c, 1)); 548 ATF_CHECK_EQ_MSG(nread, 0, "nread=%zu", nread); 549 550 RL(fcntl(readfd, F_SETFL, flags)); 551 } 552 553 static void 554 check_pollclosed_delayed_write(int writefd, int readfd, 555 int expected, int writeerror) 556 { 557 struct pollfd pfd = { .fd = writefd, .events = POLLOUT }; 558 struct timespec start, end, delta; 559 int nfds; 560 561 /* 562 * Don't let poll sleep for more than 3sec. (The close delay 563 * will be 2sec, and we make sure that we sleep at least 1sec.) 564 */ 565 REQUIRE_LIBC(alarm(3), (unsigned)-1); 566 567 /* 568 * Wait in poll(2) indefinitely (subject to the alarm) and 569 * measure how long we slept. 570 */ 571 fprintf(stderr, "poll %d\n", writefd); 572 RL(clock_gettime(CLOCK_MONOTONIC, &start)); 573 RL(nfds = poll(&pfd, 1, INFTIM)); 574 RL(clock_gettime(CLOCK_MONOTONIC, &end)); 575 fprintf(stderr, "poll %d done nfds=%d\n", writefd, nfds); 576 577 REQUIRE_LIBC(alarm(0), (unsigned)-1); 578 579 /* 580 * The reader has been closed, so write will fail immediately 581 * with EPIPE/SIGPIPE, and thus POLLOUT must be set. POLLHUP 582 * is only returned for reads, not for writes (and is mutually 583 * exclusive with POLLOUT). Except we _do_ return POLLHUP 584 * instead of POLLOUT for terminals. 585 */ 586 RL(nfds = poll(&pfd, 1, 0)); 587 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 588 ATF_CHECK_EQ_MSG(pfd.fd, writefd, "pfd.fd=%d writefd=%d", 589 pfd.fd, writefd); 590 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), expected, 591 "revents=0x%x expected=0x%x" 592 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 593 pfd.revents, expected, POLLOUT, POLLHUP, POLLIN); 594 595 /* 596 * We should have slept at least 1sec. 597 */ 598 timespecsub(&end, &start, &delta); 599 ATF_CHECK_MSG(delta.tv_sec >= 1, 600 "slept only %lld.%09ld", (long long)delta.tv_sec, delta.tv_nsec); 601 602 /* 603 * Write should fail with EPIPE/SIGPIPE now, or EIO for 604 * terminals -- and continue to do so. 605 */ 606 check_write_fail(writefd, writeerror); 607 check_write_fail(writefd, writeerror); 608 } 609 610 static void 611 check_pollclosed_delayed_write_fifopipesocket(int writefd, int readfd) 612 { 613 614 check_pollclosed_delayed_write(writefd, readfd, POLLOUT, EPIPE); 615 } 616 617 static void 618 check_pollclosed_delayed_write_terminal(int writefd, int readfd) 619 { 620 621 check_pollclosed_delayed_write(writefd, readfd, POLLHUP, EIO); 622 } 623 624 static void 625 check_pollclosed_delayed_read(int readfd, int writefd, int pollhup) 626 { 627 struct pollfd pfd; 628 struct timespec start, end, delta; 629 int nfds; 630 631 /* 632 * Don't let poll sleep for more than 3sec. (The close delay 633 * will be 2sec, and we make sure that we sleep at least 1sec.) 634 */ 635 REQUIRE_LIBC(alarm(3), (unsigned)-1); 636 637 /* 638 * Wait in poll(2) indefinitely (subject to the alarm) and 639 * measure how long we slept. 640 */ 641 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 642 fprintf(stderr, "poll %d\n", readfd); 643 RL(clock_gettime(CLOCK_MONOTONIC, &start)); 644 RL(nfds = poll(&pfd, 1, INFTIM)); 645 RL(clock_gettime(CLOCK_MONOTONIC, &end)); 646 fprintf(stderr, "poll %d done nfds=%d\n", readfd, nfds); 647 648 REQUIRE_LIBC(alarm(0), (unsigned)-1); 649 650 /* 651 * Read will yield EOF without blocking, so POLLIN should be 652 * set, and the write side has been closed, so POLLHUP should 653 * also be set, unsolicited, if this is a pipe or FIFO -- but 654 * not if it's a socket, where POLLHUP is never set. Since we 655 * didn't ask for POLLOUT, it should be clear. 656 */ 657 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 658 ATF_CHECK_EQ_MSG(pfd.fd, readfd, "pfd.fd=%d readfd=%d writefd=%d", 659 pfd.fd, readfd, writefd); 660 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 661 pollhup|POLLIN, 662 "revents=0x%x expected=0x%x" 663 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 664 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 665 666 /* 667 * We should have slept at least 1sec. 668 */ 669 timespecsub(&end, &start, &delta); 670 ATF_CHECK_MSG(delta.tv_sec >= 1, 671 "slept only %lld.%09ld", (long long)delta.tv_sec, delta.tv_nsec); 672 673 /* 674 * Read should return EOF now -- and continue to do so. 675 */ 676 check_read_eof(readfd); 677 check_read_eof(readfd); 678 679 /* 680 * POLLHUP|POLLIN state should be persistent (until the writer 681 * side is reopened if possible, as in a named pipe). 682 */ 683 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 684 RL(nfds = poll(&pfd, 1, 0)); 685 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 686 ATF_CHECK_EQ_MSG(pfd.fd, readfd, "pfd.fd=%d readfd=%d writefd=%d", 687 pfd.fd, readfd, writefd); 688 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 689 pollhup|POLLIN, 690 "revents=0x%x expected=0x%x" 691 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 692 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 693 } 694 695 static void 696 check_pollclosed_delayed_read_devfifopipe(int readfd, int writefd) 697 { 698 699 check_pollclosed_delayed_read(readfd, writefd, POLLHUP); 700 } 701 702 static void 703 check_pollclosed_delayed_read_socket(int readfd, int writefd) 704 { 705 706 check_pollclosed_delayed_read(readfd, writefd, /*no POLLHUP*/0); 707 } 708 709 static void 710 check_pollclosed_delayed_process(int pollfd, int closefd, 711 void (*check_pollhup)(int, int)) 712 { 713 pid_t pid; 714 int status; 715 716 /* 717 * Fork a child to close closefd after a 2sec delay. 718 */ 719 RL(pid = fork()); 720 if (pid == 0) { 721 sleep(2); 722 fprintf(stderr, "[child] close %d\n", closefd); 723 if (close(closefd) == -1) 724 _exit(1); 725 _exit(0); 726 } 727 728 /* 729 * Close closefd in the parent so the child has the last 730 * reference to it. 731 */ 732 fprintf(stderr, "[parent] close %d\n", closefd); 733 RL(close(closefd)); 734 735 /* 736 * Test poll(2). 737 */ 738 (*check_pollhup)(pollfd, closefd); 739 740 /* 741 * Wait for the child and make sure it exited successfully. 742 */ 743 RL(waitpid(pid, &status, 0)); 744 ATF_CHECK_EQ_MSG(status, 0, "child exited with status 0x%x", status); 745 } 746 747 static void * 748 check_pollclosed_thread(void *cookie) 749 { 750 int *closefdp = cookie; 751 752 sleep(2); 753 fprintf(stderr, "[thread] close %d\n", *closefdp); 754 RL(close(*closefdp)); 755 return NULL; 756 } 757 758 static void 759 check_pollclosed_delayed_thread(int pollfd, int closefd, 760 void (*check_pollhup)(int, int)) 761 { 762 pthread_t t; 763 764 /* 765 * Create a thread to close closefd (in this process, not a 766 * child) after a 2sec delay. 767 */ 768 RZ(pthread_create(&t, NULL, &check_pollclosed_thread, &closefd)); 769 770 /* 771 * Test poll(2). 772 */ 773 (*check_pollhup)(pollfd, closefd); 774 775 /* 776 * Wait for the thread to complete. 777 */ 778 RZ(pthread_join(t, NULL)); 779 } 780 781 static void 782 check_pollclosed_immediate_write(int writefd, int readfd, int expected, 783 int writeerror) 784 { 785 struct pollfd pfd = { .fd = writefd, .events = POLLOUT }; 786 int nfds; 787 788 /* 789 * Close the reader side immediately. 790 */ 791 fprintf(stderr, "[immediate] close %d\n", readfd); 792 RL(close(readfd)); 793 794 /* 795 * The reader has been closed, so write will fail immediately 796 * with EPIPE/SIGPIPE, and thus POLLOUT must be set. POLLHUP 797 * is only returned for reads, not for writes (and is mutually 798 * exclusive with POLLOUT). Except we _do_ return POLLHUP 799 * instead of POLLOUT for terminals. 800 */ 801 RL(nfds = poll(&pfd, 1, 0)); 802 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 803 ATF_CHECK_EQ_MSG(pfd.fd, writefd, "pfd.fd=%d writefd=%d", 804 pfd.fd, writefd); 805 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), expected, 806 "revents=0x%x expected=0x%x" 807 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 808 pfd.revents, expected, POLLOUT, POLLHUP, POLLIN); 809 810 /* 811 * Write should fail with EPIPE/SIGPIPE now -- and continue to 812 * do so. 813 */ 814 check_write_fail(writefd, writeerror); 815 check_write_fail(writefd, writeerror); 816 } 817 818 static void 819 check_pollclosed_immediate_readnone(int readfd, int writefd, int pollhup) 820 { 821 struct pollfd pfd = { .fd = readfd, .events = POLLIN }; 822 int nfds; 823 824 /* 825 * Close the writer side immediately. 826 */ 827 fprintf(stderr, "[immediate] close %d\n", writefd); 828 RL(close(writefd)); 829 830 /* 831 * Read will yield EOF without blocking, so POLLIN should be 832 * set, and the write side has been closed, so POLLHUP should 833 * be set, unsolicited, if this is a pipe or FIFO -- but not if 834 * it's a socket, where POLLHUP is never set. Since we didn't 835 * ask for POLLOUT, it should be clear. 836 */ 837 RL(nfds = poll(&pfd, 1, 0)); 838 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 839 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 840 pollhup|POLLIN, 841 "revents=0x%x expected=0x%x" 842 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 843 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 844 845 /* 846 * Read should return EOF now -- and continue to do so. 847 */ 848 check_read_eof(readfd); 849 check_read_eof(readfd); 850 } 851 852 static void 853 check_pollclosed_immediate_readsome(int readfd, int writefd, int pollhup) 854 { 855 struct pollfd pfd; 856 char buf[BUFSIZ]; 857 ssize_t nread; 858 int nfds; 859 860 /* 861 * Close the writer side immediately. 862 */ 863 fprintf(stderr, "[immediate] close %d\n", writefd); 864 RL(close(writefd)); 865 866 /* 867 * Some data should be ready to read, so POLLIN should be set, 868 * and the write side has been closed, so POLLHUP should also 869 * be set, unsolicited, if this is a pipe or FIFO -- but not if 870 * it's a socket, where POLLHUP is never set. Since we didn't 871 * ask for POLLOUT, it should be clear. 872 */ 873 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 874 RL(nfds = poll(&pfd, 1, 0)); 875 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 876 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 877 pollhup|POLLIN, 878 "revents=0x%x expected=0x%x" 879 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 880 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 881 882 /* 883 * Read all the data. Each read should complete instantly -- 884 * no blocking, either because there's data to read or because 885 * the writer has hung up and we get EOF. 886 */ 887 do { 888 REQUIRE_LIBC(alarm(1), (unsigned)-1); 889 RL(nread = read(readfd, buf, sizeof(buf))); 890 REQUIRE_LIBC(alarm(0), (unsigned)-1); 891 } while (nread != 0); 892 893 /* 894 * Read will yield EOF without blocking, so POLLIN should be 895 * set, and the write side has been closed, so POLLHUP should 896 * also be set, unsolicited, if this is a pipe or FIFO -- but 897 * not if it's a socket, where POLLHUP is never set. Since we 898 * didn't ask for POLLOUT, it should be clear. 899 */ 900 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 901 RL(nfds = poll(&pfd, 1, 0)); 902 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 903 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 904 pollhup|POLLIN, 905 "revents=0x%x expected=0x%x" 906 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 907 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 908 909 /* 910 * Read should return EOF now -- and continue to do so. 911 */ 912 check_read_eof(readfd); 913 check_read_eof(readfd); 914 915 /* 916 * POLLHUP|POLLIN state should be persistent (until the writer 917 * side is reopened if possible, as in a named pipe). 918 */ 919 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 920 RL(nfds = poll(&pfd, 1, 0)); 921 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 922 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 923 pollhup|POLLIN, 924 "revents=0x%x expected=0x%x" 925 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 926 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 927 } 928 929 static void * 930 pollclosed_fifo_writer_thread(void *cookie) 931 { 932 int *pp = cookie; 933 934 RL(*pp = open(fifo_path, O_WRONLY)); 935 return NULL; 936 } 937 938 static void * 939 pollclosed_fifo_reader_thread(void *cookie) 940 { 941 int *pp = cookie; 942 943 RL(*pp = open(fifo_path, O_RDONLY)); 944 return NULL; 945 } 946 947 static void 948 pollclosed_fifo0_setup(int *writefdp, int *readfdp) 949 { 950 int p0, p1; 951 pthread_t t; 952 953 fifo_support(); 954 955 RL(mkfifo(fifo_path, 0600)); 956 RZ(pthread_create(&t, NULL, &pollclosed_fifo_reader_thread, &p0)); 957 REQUIRE_LIBC(alarm(1), (unsigned)-1); 958 RL(p1 = open(fifo_path, O_WRONLY)); 959 REQUIRE_LIBC(alarm(0), (unsigned)-1); 960 RZ(pthread_join(t, NULL)); 961 962 *writefdp = p1; 963 *readfdp = p0; 964 } 965 966 static void 967 pollclosed_fifo1_setup(int *writefdp, int *readfdp) 968 { 969 int p0, p1; 970 pthread_t t; 971 972 fifo_support(); 973 974 RL(mkfifo(fifo_path, 0600)); 975 RZ(pthread_create(&t, NULL, &pollclosed_fifo_writer_thread, &p0)); 976 REQUIRE_LIBC(alarm(1), (unsigned)-1); 977 RL(p1 = open(fifo_path, O_RDONLY)); 978 REQUIRE_LIBC(alarm(0), (unsigned)-1); 979 RZ(pthread_join(t, NULL)); 980 981 *writefdp = p0; 982 *readfdp = p1; 983 } 984 985 static void 986 pollclosed_pipe_setup(int *writefdp, int *readfdp) 987 { 988 int p[2]; 989 990 RL(pipe(p)); 991 992 *readfdp = p[0]; /* reader side */ 993 *writefdp = p[1]; /* writer side */ 994 } 995 996 static void 997 pollclosed_ptyapp_setup(int *writefdp, int *readfdp) 998 { 999 int hostfd, appfd; 1000 struct termios t; 1001 char *pts; 1002 1003 RL(hostfd = posix_openpt(O_RDWR|O_NOCTTY)); 1004 RL(grantpt(hostfd)); 1005 RL(unlockpt(hostfd)); 1006 REQUIRE_LIBC(pts = ptsname(hostfd), NULL); 1007 RL(appfd = open(pts, O_RDWR|O_NOCTTY)); 1008 1009 RL(tcgetattr(appfd, &t)); 1010 t.c_lflag &= ~ICANON; /* block rather than drop input */ 1011 RL(tcsetattr(appfd, TCSANOW, &t)); 1012 1013 *readfdp = appfd; 1014 *writefdp = hostfd; 1015 } 1016 1017 static void 1018 pollclosed_ptyhost_setup(int *writefdp, int *readfdp) 1019 { 1020 int hostfd, appfd; 1021 struct termios t; 1022 char *pts; 1023 1024 RL(hostfd = posix_openpt(O_RDWR|O_NOCTTY)); 1025 RL(grantpt(hostfd)); 1026 RL(unlockpt(hostfd)); 1027 REQUIRE_LIBC(pts = ptsname(hostfd), NULL); 1028 RL(appfd = open(pts, O_RDWR|O_NOCTTY)); 1029 1030 RL(tcgetattr(appfd, &t)); 1031 t.c_lflag &= ~ICANON; /* block rather than drop input */ 1032 RL(tcsetattr(appfd, TCSANOW, &t)); 1033 1034 *writefdp = appfd; 1035 *readfdp = hostfd; 1036 } 1037 1038 static void 1039 pollclosed_socketpair0_setup(int *writefdp, int *readfdp) 1040 { 1041 int s[2]; 1042 1043 RL(socketpair(AF_LOCAL, SOCK_STREAM, 0, s)); 1044 *readfdp = s[0]; 1045 *writefdp = s[1]; 1046 } 1047 1048 static void 1049 pollclosed_socketpair1_setup(int *writefdp, int *readfdp) 1050 { 1051 int s[2]; 1052 1053 RL(socketpair(AF_LOCAL, SOCK_STREAM, 0, s)); 1054 *readfdp = s[1]; 1055 *writefdp = s[0]; 1056 } 1057 1058 /* 1059 * Cartesian product of: 1060 * 1061 * 1. [fifo0] first fifo opener 1062 * 2. [fifo1] second fifo opener 1063 * 3. [pipe] pipe 1064 * 4. [ptyhost] host side of pty 1065 * 5. [ptyapp] application side of pty 1066 * 6. [socketpair0] first side of socket pair 1067 * 7. [socketpair1] second side of socket pair 1068 * 1069 * with 1070 * 1071 * 1. [immediate] closed before poll starts 1072 * 2. [delayed_thread] closed by another thread after poll starts 1073 * 3. [delayed_process] closed by another process after poll starts 1074 * 1075 * with 1076 * 1077 * 1. [writefull] close reader, poll for write when buffer full 1078 * 2. [writeempty] close reader, poll for write when buffer empty 1079 * 3. [readnone] close writer, poll for read when nothing to read 1080 * 4. [readsome] close writer, poll for read when something to read 1081 * 1082 * except that in the delayed cases we only do writefull [write] and 1083 * readnone [read], because there's no delay in the writeempty/readsome 1084 * cases. 1085 */ 1086 1087 ATF_TC(pollclosed_fifo0_immediate_writefull); 1088 ATF_TC_HEAD(pollclosed_fifo0_immediate_writefull, tc) 1089 { 1090 atf_tc_set_md_var(tc, "descr", 1091 "Checks POLLHUP with closing the first opener of a named pipe"); 1092 } 1093 ATF_TC_BODY(pollclosed_fifo0_immediate_writefull, tc) 1094 { 1095 int writefd, readfd; 1096 1097 pollclosed_fifo0_setup(&writefd, &readfd); 1098 fillpipebuf(writefd); 1099 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1100 } 1101 1102 ATF_TC(pollclosed_fifo0_immediate_writeempty); 1103 ATF_TC_HEAD(pollclosed_fifo0_immediate_writeempty, tc) 1104 { 1105 atf_tc_set_md_var(tc, "descr", 1106 "Checks POLLHUP with closing the first opener of a named pipe"); 1107 } 1108 ATF_TC_BODY(pollclosed_fifo0_immediate_writeempty, tc) 1109 { 1110 int writefd, readfd; 1111 1112 pollclosed_fifo0_setup(&writefd, &readfd); 1113 /* don't fill the pipe buf */ 1114 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1115 } 1116 1117 ATF_TC(pollclosed_fifo0_immediate_readsome); 1118 ATF_TC_HEAD(pollclosed_fifo0_immediate_readsome, tc) 1119 { 1120 atf_tc_set_md_var(tc, "descr", 1121 "Checks POLLHUP with closing the first opener of a named pipe"); 1122 } 1123 ATF_TC_BODY(pollclosed_fifo0_immediate_readsome, tc) 1124 { 1125 int writefd, readfd; 1126 1127 /* 1128 * poll(2) returns nothing, when it is supposed to return 1129 * POLLHUP|POLLIN. 1130 */ 1131 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1132 1133 pollclosed_fifo1_setup(&writefd, &readfd); /* reverse r/w */ 1134 fillpipebuf(writefd); 1135 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1136 } 1137 1138 ATF_TC(pollclosed_fifo0_immediate_readnone); 1139 ATF_TC_HEAD(pollclosed_fifo0_immediate_readnone, tc) 1140 { 1141 atf_tc_set_md_var(tc, "descr", 1142 "Checks POLLHUP with closing the first opener of a named pipe"); 1143 } 1144 ATF_TC_BODY(pollclosed_fifo0_immediate_readnone, tc) 1145 { 1146 int writefd, readfd; 1147 1148 pollclosed_fifo1_setup(&writefd, &readfd); /* reverse r/w */ 1149 /* don't fill the pipe buf */ 1150 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1151 } 1152 1153 ATF_TC(pollclosed_fifo0_delayed_process_write); 1154 ATF_TC_HEAD(pollclosed_fifo0_delayed_process_write, tc) 1155 { 1156 atf_tc_set_md_var(tc, "descr", 1157 "Checks POLLHUP with closing the first opener of a named pipe"); 1158 } 1159 ATF_TC_BODY(pollclosed_fifo0_delayed_process_write, tc) 1160 { 1161 int writefd, readfd; 1162 1163 pollclosed_fifo0_setup(&writefd, &readfd); 1164 fillpipebuf(writefd); 1165 check_pollclosed_delayed_process(writefd, readfd, 1166 &check_pollclosed_delayed_write_fifopipesocket); 1167 } 1168 1169 ATF_TC(pollclosed_fifo0_delayed_process_read); 1170 ATF_TC_HEAD(pollclosed_fifo0_delayed_process_read, tc) 1171 { 1172 atf_tc_set_md_var(tc, "descr", 1173 "Checks POLLHUP with closing the first opener of a named pipe"); 1174 } 1175 ATF_TC_BODY(pollclosed_fifo0_delayed_process_read, tc) 1176 { 1177 int writefd, readfd; 1178 1179 /* 1180 * poll(2) wakes up with POLLHUP|POLLIN, but the state isn't 1181 * persistent as it is supposed to be -- it returns nothing 1182 * after that. 1183 */ 1184 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1185 1186 pollclosed_fifo1_setup(&writefd, &readfd); /* reverse r/w */ 1187 /* don't fill pipe buf */ 1188 check_pollclosed_delayed_process(readfd, writefd, 1189 &check_pollclosed_delayed_read_devfifopipe); 1190 } 1191 1192 ATF_TC(pollclosed_fifo0_delayed_thread_write); 1193 ATF_TC_HEAD(pollclosed_fifo0_delayed_thread_write, tc) 1194 { 1195 atf_tc_set_md_var(tc, "descr", 1196 "Checks POLLHUP with closing the first opener of a named pipe"); 1197 } 1198 ATF_TC_BODY(pollclosed_fifo0_delayed_thread_write, tc) 1199 { 1200 int writefd, readfd; 1201 1202 pollclosed_fifo0_setup(&writefd, &readfd); 1203 fillpipebuf(writefd); 1204 check_pollclosed_delayed_thread(writefd, readfd, 1205 &check_pollclosed_delayed_write_fifopipesocket); 1206 } 1207 1208 ATF_TC(pollclosed_fifo0_delayed_thread_read); 1209 ATF_TC_HEAD(pollclosed_fifo0_delayed_thread_read, tc) 1210 { 1211 atf_tc_set_md_var(tc, "descr", 1212 "Checks POLLHUP with closing the first opener of a named pipe"); 1213 } 1214 ATF_TC_BODY(pollclosed_fifo0_delayed_thread_read, tc) 1215 { 1216 int writefd, readfd; 1217 1218 /* 1219 * poll(2) wakes up with POLLHUP|POLLIN, but the state isn't 1220 * persistent as it is supposed to be -- it returns nothing 1221 * after that. 1222 */ 1223 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1224 1225 pollclosed_fifo1_setup(&writefd, &readfd); /* reverse r/w */ 1226 /* don't fill pipe buf */ 1227 check_pollclosed_delayed_thread(readfd, writefd, 1228 &check_pollclosed_delayed_read_devfifopipe); 1229 } 1230 1231 ATF_TC(pollclosed_fifo1_immediate_writefull); 1232 ATF_TC_HEAD(pollclosed_fifo1_immediate_writefull, tc) 1233 { 1234 atf_tc_set_md_var(tc, "descr", 1235 "Checks POLLHUP with closing the second opener of a named pipe"); 1236 } 1237 ATF_TC_BODY(pollclosed_fifo1_immediate_writefull, tc) 1238 { 1239 int writefd, readfd; 1240 1241 pollclosed_fifo1_setup(&writefd, &readfd); 1242 fillpipebuf(writefd); 1243 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1244 } 1245 1246 ATF_TC(pollclosed_fifo1_immediate_writeempty); 1247 ATF_TC_HEAD(pollclosed_fifo1_immediate_writeempty, tc) 1248 { 1249 atf_tc_set_md_var(tc, "descr", 1250 "Checks POLLHUP with closing the second opener of a named pipe"); 1251 } 1252 ATF_TC_BODY(pollclosed_fifo1_immediate_writeempty, tc) 1253 { 1254 int writefd, readfd; 1255 1256 pollclosed_fifo1_setup(&writefd, &readfd); 1257 /* don't fill the pipe buf */ 1258 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1259 } 1260 1261 ATF_TC(pollclosed_fifo1_immediate_readsome); 1262 ATF_TC_HEAD(pollclosed_fifo1_immediate_readsome, tc) 1263 { 1264 atf_tc_set_md_var(tc, "descr", 1265 "Checks POLLHUP with closing the second opener of a named pipe"); 1266 } 1267 ATF_TC_BODY(pollclosed_fifo1_immediate_readsome, tc) 1268 { 1269 int writefd, readfd; 1270 1271 /* 1272 * poll(2) returns nothing, when it is supposed to return 1273 * POLLHUP|POLLIN. 1274 */ 1275 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1276 1277 pollclosed_fifo0_setup(&writefd, &readfd); /* reverse r/w */ 1278 fillpipebuf(writefd); 1279 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1280 } 1281 1282 ATF_TC(pollclosed_fifo1_immediate_readnone); 1283 ATF_TC_HEAD(pollclosed_fifo1_immediate_readnone, tc) 1284 { 1285 atf_tc_set_md_var(tc, "descr", 1286 "Checks POLLHUP with closing the second opener of a named pipe"); 1287 } 1288 ATF_TC_BODY(pollclosed_fifo1_immediate_readnone, tc) 1289 { 1290 int writefd, readfd; 1291 1292 pollclosed_fifo0_setup(&writefd, &readfd); /* reverse r/w */ 1293 /* don't fill the pipe buf */ 1294 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1295 } 1296 1297 ATF_TC(pollclosed_fifo1_delayed_process_write); 1298 ATF_TC_HEAD(pollclosed_fifo1_delayed_process_write, tc) 1299 { 1300 atf_tc_set_md_var(tc, "descr", 1301 "Checks POLLHUP with closing the second opener of a named pipe"); 1302 } 1303 ATF_TC_BODY(pollclosed_fifo1_delayed_process_write, tc) 1304 { 1305 int writefd, readfd; 1306 1307 pollclosed_fifo1_setup(&writefd, &readfd); 1308 fillpipebuf(writefd); 1309 check_pollclosed_delayed_process(writefd, readfd, 1310 &check_pollclosed_delayed_write_fifopipesocket); 1311 } 1312 1313 ATF_TC(pollclosed_fifo1_delayed_process_read); 1314 ATF_TC_HEAD(pollclosed_fifo1_delayed_process_read, tc) 1315 { 1316 atf_tc_set_md_var(tc, "descr", 1317 "Checks POLLHUP with closing the second opener of a named pipe"); 1318 } 1319 ATF_TC_BODY(pollclosed_fifo1_delayed_process_read, tc) 1320 { 1321 int writefd, readfd; 1322 1323 /* 1324 * poll(2) wakes up with POLLHUP|POLLIN, but the state isn't 1325 * persistent as it is supposed to be -- it returns nothing 1326 * after that. 1327 */ 1328 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1329 1330 pollclosed_fifo0_setup(&writefd, &readfd); /* reverse r/w */ 1331 /* don't fill pipe buf */ 1332 check_pollclosed_delayed_process(readfd, writefd, 1333 &check_pollclosed_delayed_read_devfifopipe); 1334 } 1335 1336 ATF_TC(pollclosed_fifo1_delayed_thread_write); 1337 ATF_TC_HEAD(pollclosed_fifo1_delayed_thread_write, tc) 1338 { 1339 atf_tc_set_md_var(tc, "descr", 1340 "Checks POLLHUP with closing the second opener of a named pipe"); 1341 } 1342 ATF_TC_BODY(pollclosed_fifo1_delayed_thread_write, tc) 1343 { 1344 int writefd, readfd; 1345 1346 pollclosed_fifo1_setup(&writefd, &readfd); 1347 fillpipebuf(writefd); 1348 check_pollclosed_delayed_thread(writefd, readfd, 1349 &check_pollclosed_delayed_write_fifopipesocket); 1350 } 1351 1352 ATF_TC(pollclosed_fifo1_delayed_thread_read); 1353 ATF_TC_HEAD(pollclosed_fifo1_delayed_thread_read, tc) 1354 { 1355 atf_tc_set_md_var(tc, "descr", 1356 "Checks POLLHUP with closing the second opener of a named pipe"); 1357 } 1358 ATF_TC_BODY(pollclosed_fifo1_delayed_thread_read, tc) 1359 { 1360 int writefd, readfd; 1361 1362 /* 1363 * poll(2) wakes up with POLLHUP|POLLIN, but the state isn't 1364 * persistent as it is supposed to be -- it returns nothing 1365 * after that. 1366 */ 1367 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1368 1369 pollclosed_fifo0_setup(&writefd, &readfd); /* reverse r/w */ 1370 /* don't fill pipe buf */ 1371 check_pollclosed_delayed_process(readfd, writefd, 1372 &check_pollclosed_delayed_read_devfifopipe); 1373 } 1374 1375 ATF_TC(pollclosed_pipe_immediate_writefull); 1376 ATF_TC_HEAD(pollclosed_pipe_immediate_writefull, tc) 1377 { 1378 atf_tc_set_md_var(tc, "descr", 1379 "Checks POLLHUP with a closed pipe"); 1380 } 1381 ATF_TC_BODY(pollclosed_pipe_immediate_writefull, tc) 1382 { 1383 int writefd, readfd; 1384 1385 /* 1386 * poll(2) returns POLLHUP|POLLOUT, which is forbidden -- 1387 * POLLHUP and POLLOUT are mutually exclusive. And POLLHUP is 1388 * only supposed to be returned by polling for read, not 1389 * polling for write. So it should be POLLOUT. 1390 */ 1391 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1392 1393 pollclosed_pipe_setup(&writefd, &readfd); 1394 fillpipebuf(writefd); 1395 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1396 } 1397 1398 ATF_TC(pollclosed_pipe_immediate_writeempty); 1399 ATF_TC_HEAD(pollclosed_pipe_immediate_writeempty, tc) 1400 { 1401 atf_tc_set_md_var(tc, "descr", 1402 "Checks POLLHUP with a closed pipe"); 1403 } 1404 ATF_TC_BODY(pollclosed_pipe_immediate_writeempty, tc) 1405 { 1406 int writefd, readfd; 1407 1408 /* 1409 * poll(2) returns POLLHUP|POLLOUT, which is forbidden -- 1410 * POLLHUP and POLLOUT are mutually exclusive. And POLLHUP is 1411 * only supposed to be returned by polling for read, not 1412 * polling for write. So it should be POLLOUT. 1413 */ 1414 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1415 1416 pollclosed_pipe_setup(&writefd, &readfd); 1417 /* don't fill pipe buf */ 1418 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1419 } 1420 1421 ATF_TC(pollclosed_pipe_immediate_readsome); 1422 ATF_TC_HEAD(pollclosed_pipe_immediate_readsome, tc) 1423 { 1424 atf_tc_set_md_var(tc, "descr", 1425 "Checks POLLHUP with a closed pipe"); 1426 } 1427 ATF_TC_BODY(pollclosed_pipe_immediate_readsome, tc) 1428 { 1429 int writefd, readfd; 1430 1431 pollclosed_pipe_setup(&writefd, &readfd); 1432 fillpipebuf(writefd); 1433 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1434 } 1435 1436 ATF_TC(pollclosed_pipe_immediate_readnone); 1437 ATF_TC_HEAD(pollclosed_pipe_immediate_readnone, tc) 1438 { 1439 atf_tc_set_md_var(tc, "descr", 1440 "Checks POLLHUP with a closed pipe"); 1441 } 1442 ATF_TC_BODY(pollclosed_pipe_immediate_readnone, tc) 1443 { 1444 int writefd, readfd; 1445 1446 pollclosed_pipe_setup(&writefd, &readfd); 1447 /* don't fill pipe buf */ 1448 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1449 } 1450 1451 ATF_TC(pollclosed_pipe_delayed_process_write); 1452 ATF_TC_HEAD(pollclosed_pipe_delayed_process_write, tc) 1453 { 1454 atf_tc_set_md_var(tc, "descr", 1455 "Checks POLLHUP with a closed pipe"); 1456 } 1457 ATF_TC_BODY(pollclosed_pipe_delayed_process_write, tc) 1458 { 1459 int writefd, readfd; 1460 1461 /* 1462 * poll(2) returns POLLHUP|POLLOUT, which is forbidden -- 1463 * POLLHUP and POLLOUT are mutually exclusive. And POLLHUP is 1464 * only supposed to be returned by polling for read, not 1465 * polling for write. So it should be POLLOUT. 1466 */ 1467 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1468 1469 pollclosed_pipe_setup(&writefd, &readfd); 1470 fillpipebuf(writefd); 1471 check_pollclosed_delayed_process(writefd, readfd, 1472 &check_pollclosed_delayed_write_fifopipesocket); 1473 } 1474 1475 ATF_TC(pollclosed_pipe_delayed_process_read); 1476 ATF_TC_HEAD(pollclosed_pipe_delayed_process_read, tc) 1477 { 1478 atf_tc_set_md_var(tc, "descr", 1479 "Checks POLLHUP with a closed pipe"); 1480 } 1481 ATF_TC_BODY(pollclosed_pipe_delayed_process_read, tc) 1482 { 1483 int writefd, readfd; 1484 1485 pollclosed_pipe_setup(&writefd, &readfd); 1486 /* don't fill pipe buf */ 1487 check_pollclosed_delayed_process(readfd, writefd, 1488 &check_pollclosed_delayed_read_devfifopipe); 1489 } 1490 1491 ATF_TC(pollclosed_pipe_delayed_thread_write); 1492 ATF_TC_HEAD(pollclosed_pipe_delayed_thread_write, tc) 1493 { 1494 atf_tc_set_md_var(tc, "descr", 1495 "Checks POLLHUP with a closed pipe"); 1496 } 1497 ATF_TC_BODY(pollclosed_pipe_delayed_thread_write, tc) 1498 { 1499 int writefd, readfd; 1500 1501 /* 1502 * poll(2) returns POLLHUP|POLLOUT, which is forbidden -- 1503 * POLLHUP and POLLOUT are mutually exclusive. And POLLHUP is 1504 * only supposed to be returned by polling for read, not 1505 * polling for write. So it should be POLLOUT. 1506 */ 1507 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1508 1509 pollclosed_pipe_setup(&writefd, &readfd); 1510 fillpipebuf(writefd); 1511 check_pollclosed_delayed_thread(writefd, readfd, 1512 &check_pollclosed_delayed_write_fifopipesocket); 1513 } 1514 1515 ATF_TC(pollclosed_pipe_delayed_thread_read); 1516 ATF_TC_HEAD(pollclosed_pipe_delayed_thread_read, tc) 1517 { 1518 atf_tc_set_md_var(tc, "descr", 1519 "Checks POLLHUP with a closed pipe"); 1520 } 1521 ATF_TC_BODY(pollclosed_pipe_delayed_thread_read, tc) 1522 { 1523 int writefd, readfd; 1524 1525 pollclosed_pipe_setup(&writefd, &readfd); 1526 /* don't fill pipe buf */ 1527 check_pollclosed_delayed_thread(readfd, writefd, 1528 &check_pollclosed_delayed_read_devfifopipe); 1529 } 1530 1531 ATF_TC(pollclosed_ptyapp_immediate_writefull); 1532 ATF_TC_HEAD(pollclosed_ptyapp_immediate_writefull, tc) 1533 { 1534 atf_tc_set_md_var(tc, "descr", 1535 "Checks POLLHUP with closing the pty application side"); 1536 } 1537 ATF_TC_BODY(pollclosed_ptyapp_immediate_writefull, tc) 1538 { 1539 int writefd, readfd; 1540 1541 pollclosed_ptyapp_setup(&writefd, &readfd); 1542 fillpipebuf(writefd); 1543 check_pollclosed_immediate_write(writefd, readfd, POLLHUP, EIO); 1544 } 1545 1546 ATF_TC(pollclosed_ptyapp_immediate_writeempty); 1547 ATF_TC_HEAD(pollclosed_ptyapp_immediate_writeempty, tc) 1548 { 1549 atf_tc_set_md_var(tc, "descr", 1550 "Checks POLLHUP with closing the pty application side"); 1551 } 1552 ATF_TC_BODY(pollclosed_ptyapp_immediate_writeempty, tc) 1553 { 1554 int writefd, readfd; 1555 1556 pollclosed_ptyapp_setup(&writefd, &readfd); 1557 /* don't fill the pipe buf */ 1558 check_pollclosed_immediate_write(writefd, readfd, POLLHUP, EIO); 1559 } 1560 1561 ATF_TC(pollclosed_ptyapp_immediate_readsome); 1562 ATF_TC_HEAD(pollclosed_ptyapp_immediate_readsome, tc) 1563 { 1564 atf_tc_set_md_var(tc, "descr", 1565 "Checks POLLHUP with closing the pty application side"); 1566 } 1567 ATF_TC_BODY(pollclosed_ptyapp_immediate_readsome, tc) 1568 { 1569 int writefd, readfd; 1570 1571 /* 1572 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1573 * would return EOF without blocking. 1574 */ 1575 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1576 1577 pollclosed_ptyhost_setup(&writefd, &readfd); /* reverse r/w */ 1578 fillpipebuf(writefd); 1579 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1580 } 1581 1582 ATF_TC(pollclosed_ptyapp_immediate_readnone); 1583 ATF_TC_HEAD(pollclosed_ptyapp_immediate_readnone, tc) 1584 { 1585 atf_tc_set_md_var(tc, "descr", 1586 "Checks POLLHUP with closing the pty application side"); 1587 } 1588 ATF_TC_BODY(pollclosed_ptyapp_immediate_readnone, tc) 1589 { 1590 int writefd, readfd; 1591 1592 /* 1593 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1594 * would return EOF without blocking. 1595 */ 1596 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1597 1598 pollclosed_ptyhost_setup(&writefd, &readfd); /* reverse r/w */ 1599 /* don't fill the pipe buf */ 1600 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1601 } 1602 1603 ATF_TC(pollclosed_ptyapp_delayed_process_write); 1604 ATF_TC_HEAD(pollclosed_ptyapp_delayed_process_write, tc) 1605 { 1606 atf_tc_set_md_var(tc, "descr", 1607 "Checks POLLHUP with closing the pty application side"); 1608 } 1609 ATF_TC_BODY(pollclosed_ptyapp_delayed_process_write, tc) 1610 { 1611 int writefd, readfd; 1612 1613 /* 1614 * The poll(2) call is not woken by the concurrent close(2) 1615 * call. 1616 */ 1617 atf_tc_expect_signal(SIGALRM, "PR kern/59056: poll POLLHUP bugs"); 1618 1619 pollclosed_ptyapp_setup(&writefd, &readfd); 1620 fillpipebuf(writefd); 1621 check_pollclosed_delayed_process(writefd, readfd, 1622 &check_pollclosed_delayed_write_terminal); 1623 } 1624 1625 ATF_TC(pollclosed_ptyapp_delayed_process_read); 1626 ATF_TC_HEAD(pollclosed_ptyapp_delayed_process_read, tc) 1627 { 1628 atf_tc_set_md_var(tc, "descr", 1629 "Checks POLLHUP with closing the pty application side"); 1630 } 1631 ATF_TC_BODY(pollclosed_ptyapp_delayed_process_read, tc) 1632 { 1633 int writefd, readfd; 1634 1635 /* 1636 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1637 * would return EOF without blocking. 1638 */ 1639 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1640 1641 pollclosed_ptyhost_setup(&writefd, &readfd); /* reverse r/w */ 1642 /* don't fill pipe buf */ 1643 check_pollclosed_delayed_process(readfd, writefd, 1644 &check_pollclosed_delayed_read_devfifopipe); 1645 } 1646 1647 ATF_TC(pollclosed_ptyapp_delayed_thread_write); 1648 ATF_TC_HEAD(pollclosed_ptyapp_delayed_thread_write, tc) 1649 { 1650 atf_tc_set_md_var(tc, "descr", 1651 "Checks POLLHUP with closing the pty application side"); 1652 } 1653 ATF_TC_BODY(pollclosed_ptyapp_delayed_thread_write, tc) 1654 { 1655 int writefd, readfd; 1656 1657 /* 1658 * The poll(2) call is not woken by the concurrent close(2) 1659 * call. 1660 */ 1661 atf_tc_expect_signal(SIGALRM, "PR kern/59056: poll POLLHUP bugs"); 1662 1663 pollclosed_ptyapp_setup(&writefd, &readfd); 1664 fillpipebuf(writefd); 1665 check_pollclosed_delayed_thread(writefd, readfd, 1666 &check_pollclosed_delayed_write_terminal); 1667 } 1668 1669 ATF_TC(pollclosed_ptyapp_delayed_thread_read); 1670 ATF_TC_HEAD(pollclosed_ptyapp_delayed_thread_read, tc) 1671 { 1672 atf_tc_set_md_var(tc, "descr", 1673 "Checks POLLHUP with closing the pty application side"); 1674 } 1675 ATF_TC_BODY(pollclosed_ptyapp_delayed_thread_read, tc) 1676 { 1677 int writefd, readfd; 1678 1679 /* 1680 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1681 * would return EOF without blocking. 1682 */ 1683 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1684 1685 pollclosed_ptyhost_setup(&writefd, &readfd); /* reverse r/w */ 1686 /* don't fill pipe buf */ 1687 check_pollclosed_delayed_process(readfd, writefd, 1688 &check_pollclosed_delayed_read_devfifopipe); 1689 } 1690 1691 ATF_TC(pollclosed_ptyhost_immediate_writefull); 1692 ATF_TC_HEAD(pollclosed_ptyhost_immediate_writefull, tc) 1693 { 1694 atf_tc_set_md_var(tc, "descr", 1695 "Checks POLLHUP with closing the pty host side"); 1696 } 1697 ATF_TC_BODY(pollclosed_ptyhost_immediate_writefull, tc) 1698 { 1699 int writefd, readfd; 1700 1701 pollclosed_ptyhost_setup(&writefd, &readfd); 1702 fillpipebuf(writefd); 1703 check_pollclosed_immediate_write(writefd, readfd, POLLHUP, EIO); 1704 } 1705 1706 ATF_TC(pollclosed_ptyhost_immediate_writeempty); 1707 ATF_TC_HEAD(pollclosed_ptyhost_immediate_writeempty, tc) 1708 { 1709 atf_tc_set_md_var(tc, "descr", 1710 "Checks POLLHUP with closing the pty host side"); 1711 } 1712 ATF_TC_BODY(pollclosed_ptyhost_immediate_writeempty, tc) 1713 { 1714 int writefd, readfd; 1715 1716 pollclosed_ptyhost_setup(&writefd, &readfd); 1717 /* don't fill the pipe buf */ 1718 check_pollclosed_immediate_write(writefd, readfd, POLLHUP, EIO); 1719 } 1720 1721 ATF_TC(pollclosed_ptyhost_immediate_readsome); 1722 ATF_TC_HEAD(pollclosed_ptyhost_immediate_readsome, tc) 1723 { 1724 atf_tc_set_md_var(tc, "descr", 1725 "Checks POLLHUP with closing the pty host side"); 1726 } 1727 ATF_TC_BODY(pollclosed_ptyhost_immediate_readsome, tc) 1728 { 1729 int writefd, readfd; 1730 1731 /* 1732 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1733 * would return EOF without blocking. 1734 */ 1735 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1736 1737 pollclosed_ptyapp_setup(&writefd, &readfd); /* reverse r/w */ 1738 fillpipebuf(writefd); 1739 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1740 } 1741 1742 ATF_TC(pollclosed_ptyhost_immediate_readnone); 1743 ATF_TC_HEAD(pollclosed_ptyhost_immediate_readnone, tc) 1744 { 1745 atf_tc_set_md_var(tc, "descr", 1746 "Checks POLLHUP with closing the pty host side"); 1747 } 1748 ATF_TC_BODY(pollclosed_ptyhost_immediate_readnone, tc) 1749 { 1750 int writefd, readfd; 1751 1752 /* 1753 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1754 * would return EOF without blocking. 1755 */ 1756 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1757 1758 pollclosed_ptyapp_setup(&writefd, &readfd); /* reverse r/w */ 1759 /* don't fill the pipe buf */ 1760 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1761 } 1762 1763 ATF_TC(pollclosed_ptyhost_delayed_process_write); 1764 ATF_TC_HEAD(pollclosed_ptyhost_delayed_process_write, tc) 1765 { 1766 atf_tc_set_md_var(tc, "descr", 1767 "Checks POLLHUP with closing the pty host side"); 1768 } 1769 ATF_TC_BODY(pollclosed_ptyhost_delayed_process_write, tc) 1770 { 1771 int writefd, readfd; 1772 1773 pollclosed_ptyhost_setup(&writefd, &readfd); 1774 fillpipebuf(writefd); 1775 check_pollclosed_delayed_process(writefd, readfd, 1776 &check_pollclosed_delayed_write_terminal); 1777 } 1778 1779 ATF_TC(pollclosed_ptyhost_delayed_process_read); 1780 ATF_TC_HEAD(pollclosed_ptyhost_delayed_process_read, tc) 1781 { 1782 atf_tc_set_md_var(tc, "descr", 1783 "Checks POLLHUP with closing the pty host side"); 1784 } 1785 ATF_TC_BODY(pollclosed_ptyhost_delayed_process_read, tc) 1786 { 1787 int writefd, readfd; 1788 1789 /* 1790 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1791 * would return EOF without blocking. 1792 */ 1793 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1794 1795 pollclosed_ptyapp_setup(&writefd, &readfd); /* reverse r/w */ 1796 /* don't fill pipe buf */ 1797 check_pollclosed_delayed_process(readfd, writefd, 1798 &check_pollclosed_delayed_read_devfifopipe); 1799 } 1800 1801 ATF_TC(pollclosed_ptyhost_delayed_thread_write); 1802 ATF_TC_HEAD(pollclosed_ptyhost_delayed_thread_write, tc) 1803 { 1804 atf_tc_set_md_var(tc, "descr", 1805 "Checks POLLHUP with closing the pty host side"); 1806 } 1807 ATF_TC_BODY(pollclosed_ptyhost_delayed_thread_write, tc) 1808 { 1809 int writefd, readfd; 1810 1811 pollclosed_ptyhost_setup(&writefd, &readfd); 1812 fillpipebuf(writefd); 1813 check_pollclosed_delayed_thread(writefd, readfd, 1814 &check_pollclosed_delayed_write_terminal); 1815 } 1816 1817 ATF_TC(pollclosed_ptyhost_delayed_thread_read); 1818 ATF_TC_HEAD(pollclosed_ptyhost_delayed_thread_read, tc) 1819 { 1820 atf_tc_set_md_var(tc, "descr", 1821 "Checks POLLHUP with closing the pty host side"); 1822 } 1823 ATF_TC_BODY(pollclosed_ptyhost_delayed_thread_read, tc) 1824 { 1825 int writefd, readfd; 1826 1827 /* 1828 * poll(2) returns POLLHUP but not POLLIN even though read(2) 1829 * would return EOF without blocking. 1830 */ 1831 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1832 1833 pollclosed_ptyapp_setup(&writefd, &readfd); /* reverse r/w */ 1834 /* don't fill pipe buf */ 1835 check_pollclosed_delayed_thread(readfd, writefd, 1836 &check_pollclosed_delayed_read_devfifopipe); 1837 } 1838 1839 ATF_TC(pollclosed_socketpair0_immediate_writefull); 1840 ATF_TC_HEAD(pollclosed_socketpair0_immediate_writefull, tc) 1841 { 1842 atf_tc_set_md_var(tc, "descr", 1843 "Checks POLLHUP with closing the first half of a socketpair"); 1844 } 1845 ATF_TC_BODY(pollclosed_socketpair0_immediate_writefull, tc) 1846 { 1847 int writefd, readfd; 1848 1849 pollclosed_socketpair0_setup(&writefd, &readfd); 1850 fillpipebuf(writefd); 1851 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1852 } 1853 1854 ATF_TC(pollclosed_socketpair0_immediate_writeempty); 1855 ATF_TC_HEAD(pollclosed_socketpair0_immediate_writeempty, tc) 1856 { 1857 atf_tc_set_md_var(tc, "descr", 1858 "Checks POLLHUP with closing the first half of a socketpair"); 1859 } 1860 ATF_TC_BODY(pollclosed_socketpair0_immediate_writeempty, tc) 1861 { 1862 int writefd, readfd; 1863 1864 pollclosed_socketpair0_setup(&writefd, &readfd); 1865 /* don't fill the pipe buf */ 1866 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1867 } 1868 1869 ATF_TC(pollclosed_socketpair0_immediate_readsome); 1870 ATF_TC_HEAD(pollclosed_socketpair0_immediate_readsome, tc) 1871 { 1872 atf_tc_set_md_var(tc, "descr", 1873 "Checks POLLHUP with closing the first half of a socketpair"); 1874 } 1875 ATF_TC_BODY(pollclosed_socketpair0_immediate_readsome, tc) 1876 { 1877 int writefd, readfd; 1878 1879 pollclosed_socketpair1_setup(&writefd, &readfd); /* reverse r/w */ 1880 fillpipebuf(writefd); 1881 check_pollclosed_immediate_readsome(readfd, writefd, /*no POLLHUP*/0); 1882 } 1883 1884 ATF_TC(pollclosed_socketpair0_immediate_readnone); 1885 ATF_TC_HEAD(pollclosed_socketpair0_immediate_readnone, tc) 1886 { 1887 atf_tc_set_md_var(tc, "descr", 1888 "Checks POLLHUP with closing the first half of a socketpair"); 1889 } 1890 ATF_TC_BODY(pollclosed_socketpair0_immediate_readnone, tc) 1891 { 1892 int writefd, readfd; 1893 1894 pollclosed_socketpair1_setup(&writefd, &readfd); /* reverse r/w */ 1895 /* don't fill the pipe buf */ 1896 check_pollclosed_immediate_readnone(readfd, writefd, /*no POLLHUP*/0); 1897 } 1898 1899 ATF_TC(pollclosed_socketpair0_delayed_process_write); 1900 ATF_TC_HEAD(pollclosed_socketpair0_delayed_process_write, tc) 1901 { 1902 atf_tc_set_md_var(tc, "descr", 1903 "Checks POLLHUP with closing the first half of a socketpair"); 1904 } 1905 ATF_TC_BODY(pollclosed_socketpair0_delayed_process_write, tc) 1906 { 1907 int writefd, readfd; 1908 1909 pollclosed_socketpair0_setup(&writefd, &readfd); 1910 fillpipebuf(writefd); 1911 check_pollclosed_delayed_process(writefd, readfd, 1912 &check_pollclosed_delayed_write_fifopipesocket); 1913 } 1914 1915 ATF_TC(pollclosed_socketpair0_delayed_process_read); 1916 ATF_TC_HEAD(pollclosed_socketpair0_delayed_process_read, tc) 1917 { 1918 atf_tc_set_md_var(tc, "descr", 1919 "Checks POLLHUP with closing the first half of a socketpair"); 1920 } 1921 ATF_TC_BODY(pollclosed_socketpair0_delayed_process_read, tc) 1922 { 1923 int writefd, readfd; 1924 1925 pollclosed_socketpair1_setup(&writefd, &readfd); /* reverse r/w */ 1926 /* don't fill pipe buf */ 1927 check_pollclosed_delayed_process(readfd, writefd, 1928 &check_pollclosed_delayed_read_socket); 1929 } 1930 1931 ATF_TC(pollclosed_socketpair0_delayed_thread_write); 1932 ATF_TC_HEAD(pollclosed_socketpair0_delayed_thread_write, tc) 1933 { 1934 atf_tc_set_md_var(tc, "descr", 1935 "Checks POLLHUP with closing the first half of a socketpair"); 1936 } 1937 ATF_TC_BODY(pollclosed_socketpair0_delayed_thread_write, tc) 1938 { 1939 int writefd, readfd; 1940 1941 pollclosed_socketpair0_setup(&writefd, &readfd); 1942 fillpipebuf(writefd); 1943 check_pollclosed_delayed_thread(writefd, readfd, 1944 &check_pollclosed_delayed_write_fifopipesocket); 1945 } 1946 1947 ATF_TC(pollclosed_socketpair0_delayed_thread_read); 1948 ATF_TC_HEAD(pollclosed_socketpair0_delayed_thread_read, tc) 1949 { 1950 atf_tc_set_md_var(tc, "descr", 1951 "Checks POLLHUP with closing the first half of a socketpair"); 1952 } 1953 ATF_TC_BODY(pollclosed_socketpair0_delayed_thread_read, tc) 1954 { 1955 int writefd, readfd; 1956 1957 pollclosed_socketpair1_setup(&writefd, &readfd); /* reverse r/w */ 1958 /* don't fill pipe buf */ 1959 check_pollclosed_delayed_thread(readfd, writefd, 1960 &check_pollclosed_delayed_read_socket); 1961 } 1962 1963 ATF_TC(pollclosed_socketpair1_immediate_writefull); 1964 ATF_TC_HEAD(pollclosed_socketpair1_immediate_writefull, tc) 1965 { 1966 atf_tc_set_md_var(tc, "descr", 1967 "Checks POLLHUP with closing the second half of a socketpair"); 1968 } 1969 ATF_TC_BODY(pollclosed_socketpair1_immediate_writefull, tc) 1970 { 1971 int writefd, readfd; 1972 1973 pollclosed_socketpair1_setup(&writefd, &readfd); 1974 fillpipebuf(writefd); 1975 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1976 } 1977 1978 ATF_TC(pollclosed_socketpair1_immediate_writeempty); 1979 ATF_TC_HEAD(pollclosed_socketpair1_immediate_writeempty, tc) 1980 { 1981 atf_tc_set_md_var(tc, "descr", 1982 "Checks POLLHUP with closing the second half of a socketpair"); 1983 } 1984 ATF_TC_BODY(pollclosed_socketpair1_immediate_writeempty, tc) 1985 { 1986 int writefd, readfd; 1987 1988 pollclosed_socketpair1_setup(&writefd, &readfd); 1989 /* don't fill the pipe buf */ 1990 check_pollclosed_immediate_write(writefd, readfd, POLLOUT, EPIPE); 1991 } 1992 1993 ATF_TC(pollclosed_socketpair1_immediate_readsome); 1994 ATF_TC_HEAD(pollclosed_socketpair1_immediate_readsome, tc) 1995 { 1996 atf_tc_set_md_var(tc, "descr", 1997 "Checks POLLHUP with closing the second half of a socketpair"); 1998 } 1999 ATF_TC_BODY(pollclosed_socketpair1_immediate_readsome, tc) 2000 { 2001 int writefd, readfd; 2002 2003 pollclosed_socketpair0_setup(&writefd, &readfd); /* reverse r/w */ 2004 fillpipebuf(writefd); 2005 check_pollclosed_immediate_readsome(readfd, writefd, /*no POLLHUP*/0); 2006 } 2007 2008 ATF_TC(pollclosed_socketpair1_immediate_readnone); 2009 ATF_TC_HEAD(pollclosed_socketpair1_immediate_readnone, tc) 2010 { 2011 atf_tc_set_md_var(tc, "descr", 2012 "Checks POLLHUP with closing the second half of a socketpair"); 2013 } 2014 ATF_TC_BODY(pollclosed_socketpair1_immediate_readnone, tc) 2015 { 2016 int writefd, readfd; 2017 2018 pollclosed_socketpair0_setup(&writefd, &readfd); /* reverse r/w */ 2019 /* don't fill the pipe buf */ 2020 check_pollclosed_immediate_readnone(readfd, writefd, /*no POLLHUP*/0); 2021 } 2022 2023 ATF_TC(pollclosed_socketpair1_delayed_process_write); 2024 ATF_TC_HEAD(pollclosed_socketpair1_delayed_process_write, tc) 2025 { 2026 atf_tc_set_md_var(tc, "descr", 2027 "Checks POLLHUP with closing the second half of a socketpair"); 2028 } 2029 ATF_TC_BODY(pollclosed_socketpair1_delayed_process_write, tc) 2030 { 2031 int writefd, readfd; 2032 2033 pollclosed_socketpair1_setup(&writefd, &readfd); 2034 fillpipebuf(writefd); 2035 check_pollclosed_delayed_process(writefd, readfd, 2036 &check_pollclosed_delayed_write_fifopipesocket); 2037 } 2038 2039 ATF_TC(pollclosed_socketpair1_delayed_process_read); 2040 ATF_TC_HEAD(pollclosed_socketpair1_delayed_process_read, tc) 2041 { 2042 atf_tc_set_md_var(tc, "descr", 2043 "Checks POLLHUP with closing the second half of a socketpair"); 2044 } 2045 ATF_TC_BODY(pollclosed_socketpair1_delayed_process_read, tc) 2046 { 2047 int writefd, readfd; 2048 2049 pollclosed_socketpair0_setup(&writefd, &readfd); /* reverse r/w */ 2050 /* don't fill pipe buf */ 2051 check_pollclosed_delayed_process(readfd, writefd, 2052 &check_pollclosed_delayed_read_socket); 2053 } 2054 2055 ATF_TC(pollclosed_socketpair1_delayed_thread_write); 2056 ATF_TC_HEAD(pollclosed_socketpair1_delayed_thread_write, tc) 2057 { 2058 atf_tc_set_md_var(tc, "descr", 2059 "Checks POLLHUP with closing the second half of a socketpair"); 2060 } 2061 ATF_TC_BODY(pollclosed_socketpair1_delayed_thread_write, tc) 2062 { 2063 int writefd, readfd; 2064 2065 pollclosed_socketpair1_setup(&writefd, &readfd); 2066 fillpipebuf(writefd); 2067 check_pollclosed_delayed_thread(writefd, readfd, 2068 &check_pollclosed_delayed_write_fifopipesocket); 2069 } 2070 2071 ATF_TC(pollclosed_socketpair1_delayed_thread_read); 2072 ATF_TC_HEAD(pollclosed_socketpair1_delayed_thread_read, tc) 2073 { 2074 atf_tc_set_md_var(tc, "descr", 2075 "Checks POLLHUP with closing the second half of a socketpair"); 2076 } 2077 ATF_TC_BODY(pollclosed_socketpair1_delayed_thread_read, tc) 2078 { 2079 int writefd, readfd; 2080 2081 pollclosed_socketpair0_setup(&writefd, &readfd); /* reverse r/w */ 2082 /* don't fill pipe buf */ 2083 check_pollclosed_delayed_process(readfd, writefd, 2084 &check_pollclosed_delayed_read_socket); 2085 } 2086 2087 ATF_TP_ADD_TCS(tp) 2088 { 2089 2090 ATF_TP_ADD_TC(tp, 3way); 2091 ATF_TP_ADD_TC(tp, basic); 2092 ATF_TP_ADD_TC(tp, err); 2093 2094 ATF_TP_ADD_TC(tp, fifo_inout); 2095 ATF_TP_ADD_TC(tp, fifo_hup1); 2096 ATF_TP_ADD_TC(tp, fifo_hup2); 2097 2098 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_writefull); 2099 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_writefull); 2100 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_writefull); 2101 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_immediate_writefull); 2102 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_immediate_writefull); 2103 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_writefull); 2104 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_writefull); 2105 2106 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_writeempty); 2107 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_writeempty); 2108 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_writeempty); 2109 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_immediate_writeempty); 2110 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_immediate_writeempty); 2111 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_writeempty); 2112 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_writeempty); 2113 2114 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_readsome); 2115 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_readsome); 2116 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_readsome); 2117 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_immediate_readsome); 2118 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_immediate_readsome); 2119 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_readsome); 2120 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_readsome); 2121 2122 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_readnone); 2123 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_readnone); 2124 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_readnone); 2125 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_immediate_readnone); 2126 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_immediate_readnone); 2127 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_readnone); 2128 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_readnone); 2129 2130 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_process_write); 2131 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_process_write); 2132 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_process_write); 2133 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_delayed_process_write); 2134 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_delayed_process_write); 2135 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_process_write); 2136 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_process_write); 2137 2138 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_process_read); 2139 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_process_read); 2140 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_process_read); 2141 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_delayed_process_read); 2142 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_delayed_process_read); 2143 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_process_read); 2144 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_process_read); 2145 2146 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_thread_write); 2147 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_thread_write); 2148 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_thread_write); 2149 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_delayed_thread_write); 2150 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_delayed_thread_write); 2151 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_thread_write); 2152 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_thread_write); 2153 2154 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_thread_read); 2155 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_thread_read); 2156 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_thread_read); 2157 ATF_TP_ADD_TC(tp, pollclosed_ptyapp_delayed_thread_read); 2158 ATF_TP_ADD_TC(tp, pollclosed_ptyhost_delayed_thread_read); 2159 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_thread_read); 2160 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_thread_read); 2161 2162 return atf_no_error(); 2163 } 2164
Indexes created Sat Sep 20 22:09:52 GMT 2025