t_poll.c revision 1.11
1 /* $NetBSD: t_poll.c,v 1.11 2025/02/09 17:10:37 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/socket.h> 33 #include <sys/stat.h> 34 #include <sys/time.h> 35 #include <sys/wait.h> 36 37 #include <atf-c.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <paths.h> 41 #include <poll.h> 42 #include <pthread.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <signal.h> 46 #include <unistd.h> 47 48 #include "h_macros.h" 49 50 static int desc; 51 52 static void 53 child1(void) 54 { 55 struct pollfd pfd; 56 57 pfd.fd = desc; 58 pfd.events = POLLIN | POLLHUP | POLLOUT; 59 60 (void)poll(&pfd, 1, 2000); 61 (void)printf("child1 exit\n"); 62 } 63 64 static void 65 child2(void) 66 { 67 struct pollfd pfd; 68 69 pfd.fd = desc; 70 pfd.events = POLLIN | POLLHUP | POLLOUT; 71 72 (void)sleep(1); 73 (void)poll(&pfd, 1, INFTIM); 74 (void)printf("child2 exit\n"); 75 } 76 77 static void 78 child3(void) 79 { 80 struct pollfd pfd; 81 82 (void)sleep(5); 83 84 pfd.fd = desc; 85 pfd.events = POLLIN | POLLHUP | POLLOUT; 86 87 (void)poll(&pfd, 1, INFTIM); 88 (void)printf("child3 exit\n"); 89 } 90 91 ATF_TC(3way); 92 ATF_TC_HEAD(3way, tc) 93 { 94 atf_tc_set_md_var(tc, "timeout", "15"); 95 atf_tc_set_md_var(tc, "descr", 96 "Check for 3-way collision for descriptor. First child comes " 97 "and polls on descriptor, second child comes and polls, first " 98 "child times out and exits, third child comes and polls. When " 99 "the wakeup event happens, the two remaining children should " 100 "both be awaken. (kern/17517)"); 101 } 102 103 ATF_TC_BODY(3way, tc) 104 { 105 int pf[2]; 106 int status, i; 107 pid_t pid; 108 ssize_t nwrit; 109 110 RL(pipe(pf)); 111 desc = pf[0]; 112 113 RL(pid = fork()); 114 if (pid == 0) { 115 if (close(pf[1]) == -1) 116 _exit(1); 117 child1(); 118 _exit(0); 119 /* NOTREACHED */ 120 } 121 122 RL(pid = fork()); 123 if (pid == 0) { 124 if (close(pf[1]) == -1) 125 _exit(1); 126 child2(); 127 _exit(0); 128 /* NOTREACHED */ 129 } 130 131 RL(pid = fork()); 132 if (pid == 0) { 133 if (close(pf[1]) == -1) 134 _exit(1); 135 child3(); 136 _exit(0); 137 /* NOTREACHED */ 138 } 139 140 (void)sleep(10); 141 142 (void)printf("parent write\n"); 143 144 RL(nwrit = write(pf[1], "konec\n", 6)); 145 ATF_REQUIRE_EQ_MSG(nwrit, 6, "nwrit=%zd", nwrit); 146 147 for (i = 0; i < 3; i++) 148 RL(wait(&status)); 149 150 (void)printf("parent terminated\n"); 151 } 152 153 ATF_TC(basic); 154 ATF_TC_HEAD(basic, tc) 155 { 156 atf_tc_set_md_var(tc, "timeout", "10"); 157 atf_tc_set_md_var(tc, "descr", 158 "Basis functionality test for poll(2)"); 159 } 160 161 ATF_TC_BODY(basic, tc) 162 { 163 int fds[2]; 164 struct pollfd pfds[2]; 165 int ret; 166 ssize_t nwrit; 167 168 RL(pipe(fds)); 169 170 pfds[0].fd = fds[0]; 171 pfds[0].events = POLLIN; 172 pfds[1].fd = fds[1]; 173 pfds[1].events = POLLOUT; 174 175 /* 176 * Check that we get a timeout waiting for data on the read end 177 * of our pipe. 178 */ 179 pfds[0].revents = -1; 180 pfds[1].revents = -1; 181 RL(ret = poll(&pfds[0], 1, 1)); 182 ATF_REQUIRE_EQ_MSG(ret, 0, "got: %d", ret); 183 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents); 184 ATF_REQUIRE_EQ_MSG(pfds[1].revents, -1, "got: %d", pfds[1].revents); 185 186 /* Check that the write end of the pipe as reported as ready. */ 187 pfds[0].revents = -1; 188 pfds[1].revents = -1; 189 RL(ret = poll(&pfds[1], 1, 1)); 190 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 191 ATF_REQUIRE_EQ_MSG(pfds[0].revents, -1, "got: %d", pfds[0].revents); 192 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",\ 193 pfds[1].revents); 194 195 /* Check that only the write end of the pipe as reported as ready. */ 196 pfds[0].revents = -1; 197 pfds[1].revents = -1; 198 RL(ret = poll(pfds, 2, 1)); 199 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 200 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents); 201 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d", 202 pfds[1].revents); 203 204 /* Write data to our pipe. */ 205 RL(nwrit = write(fds[1], "", 1)); 206 ATF_REQUIRE_EQ_MSG(nwrit, 1, "nwrit=%zd", nwrit); 207 208 /* Check that both ends of our pipe are reported as ready. */ 209 pfds[0].revents = -1; 210 pfds[1].revents = -1; 211 RL(ret = poll(pfds, 2, 1)); 212 ATF_REQUIRE_EQ_MSG(ret, 2, "got: %d", ret); 213 ATF_REQUIRE_EQ_MSG(pfds[0].revents, POLLIN, "got: %d", 214 pfds[0].revents); 215 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d", 216 pfds[1].revents); 217 218 RL(close(fds[0])); 219 RL(close(fds[1])); 220 } 221 222 ATF_TC(err); 223 ATF_TC_HEAD(err, tc) 224 { 225 atf_tc_set_md_var(tc, "descr", "Check errors from poll(2)"); 226 } 227 228 ATF_TC_BODY(err, tc) 229 { 230 struct pollfd pfd; 231 int fd = 0; 232 233 pfd.fd = fd; 234 pfd.events = POLLIN; 235 236 errno = 0; 237 ATF_REQUIRE_ERRNO(EFAULT, poll((struct pollfd *)-1, 1, -1) == -1); 238 239 errno = 0; 240 ATF_REQUIRE_ERRNO(EINVAL, poll(&pfd, 1, -2) == -1); 241 } 242 243 static const char fifo_path[] = "pollhup_fifo"; 244 245 static void 246 fifo_support(void) 247 { 248 249 errno = 0; 250 if (mkfifo(fifo_path, 0600) == 0) { 251 RL(unlink(fifo_path)); 252 return; 253 } 254 255 if (errno == EOPNOTSUPP) { 256 atf_tc_skip("the kernel does not support FIFOs"); 257 } else { 258 atf_tc_fail("mkfifo(2) failed"); 259 } 260 } 261 262 ATF_TC_WITH_CLEANUP(fifo_inout); 263 ATF_TC_HEAD(fifo_inout, tc) 264 { 265 atf_tc_set_md_var(tc, "descr", 266 "Check POLLIN/POLLOUT behavior with fifos"); 267 } 268 269 ATF_TC_BODY(fifo_inout, tc) 270 { 271 struct pollfd pfd[2]; 272 char *buf; 273 int rfd, wfd; 274 long pipe_buf; 275 int ret; 276 ssize_t nwrit, nread; 277 278 fifo_support(); 279 280 RL(mkfifo(fifo_path, 0600)); 281 RL(rfd = open(fifo_path, O_RDONLY | O_NONBLOCK)); 282 RL(wfd = open(fifo_path, O_WRONLY | O_NONBLOCK)); 283 284 /* Get the maximum atomic pipe write size. */ 285 pipe_buf = fpathconf(wfd, _PC_PIPE_BUF); 286 ATF_REQUIRE_MSG(pipe_buf > 1, "pipe_buf=%ld", pipe_buf); 287 288 REQUIRE_LIBC(buf = malloc(pipe_buf), NULL); 289 290 memset(&pfd, 0, sizeof(pfd)); 291 pfd[0].fd = rfd; 292 pfd[0].events = POLLIN | POLLRDNORM; 293 pfd[1].fd = wfd; 294 pfd[1].events = POLLOUT | POLLWRNORM; 295 296 /* We expect the FIFO to be writable but not readable. */ 297 RL(ret = poll(pfd, 2, 0)); 298 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 299 ATF_REQUIRE_EQ_MSG(pfd[0].revents, 0, 300 "pfd[0].revents=0x%x", pfd[0].revents); 301 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 302 "pfd[1].revents=0x%x", pfd[1].revents); 303 304 /* Write a single byte of data into the FIFO. */ 305 RL(nwrit = write(wfd, buf, 1)); 306 ATF_REQUIRE_EQ_MSG(nwrit, 1, "nwrit=%zd", nwrit); 307 308 /* We expect the FIFO to be readable and writable. */ 309 RL(ret = poll(pfd, 2, 0)); 310 ATF_REQUIRE_EQ_MSG(ret, 2, "got: %d", ret); 311 ATF_REQUIRE_EQ_MSG(pfd[0].revents, POLLIN|POLLRDNORM, 312 "pfd[0].revents=0x%x", pfd[0].revents); 313 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 314 "pfd[1].revents=0x%x", pfd[1].revents); 315 316 /* Read that single byte back out. */ 317 RL(nread = read(rfd, buf, 1)); 318 ATF_REQUIRE_EQ_MSG(nread, 1, "nread=%zd", nread); 319 320 /* 321 * Write data into the FIFO until it is full, which is 322 * defined as insufficient buffer space to hold a the 323 * maximum atomic pipe write size. 324 */ 325 while (write(wfd, buf, pipe_buf) != -1) { 326 continue; 327 } 328 ATF_REQUIRE_EQ_MSG(errno, EAGAIN, "errno=%d", errno); 329 330 /* We expect the FIFO to be readble but not writable. */ 331 RL(ret = poll(pfd, 2, 0)); 332 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 333 ATF_REQUIRE_EQ_MSG(pfd[0].revents, POLLIN|POLLRDNORM, 334 "pfd[0].revents=0x%x", pfd[0].revents); 335 ATF_REQUIRE_EQ_MSG(pfd[1].revents, 0, 336 "pfd[1].revents=0x%x", pfd[1].revents); 337 338 /* Read a single byte of data from the FIFO. */ 339 RL(nread = read(rfd, buf, 1)); 340 ATF_REQUIRE_EQ_MSG(nread, 1, "nread=%zd", nread); 341 342 /* 343 * Because we have read only a single byte out, there will 344 * be insufficient space for a pipe_buf-sized message, so 345 * the FIFO should still not be writable. 346 */ 347 RL(ret = poll(pfd, 2, 0)); 348 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 349 ATF_REQUIRE_EQ_MSG(pfd[0].revents, POLLIN|POLLRDNORM, 350 "pfd[0].revents=0x%x", pfd[0].revents); 351 ATF_REQUIRE_EQ_MSG(pfd[1].revents, 0, 352 "pfd[1].revents=0x%x", pfd[1].revents); 353 354 /* 355 * Now read enough so that exactly pipe_buf space should 356 * be available. The FIFO should be writable after that. 357 * N.B. we don't care if it's readable at this point. 358 */ 359 RL(nread = read(rfd, buf, pipe_buf - 1)); 360 ATF_REQUIRE_EQ_MSG(nread, pipe_buf - 1, "nread=%zd pipe_buf-1=%ld", 361 nread, pipe_buf - 1); 362 RL(ret = poll(pfd, 2, 0)); 363 ATF_REQUIRE_MSG(ret >= 1, "got: %d", ret); 364 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 365 "pfd[1].revents=0x%x", pfd[1].revents); 366 367 /* 368 * Now read all of the data out of the FIFO and ensure that 369 * we get back to the initial state. 370 */ 371 while (read(rfd, buf, pipe_buf) != -1) { 372 continue; 373 } 374 ATF_REQUIRE_EQ_MSG(errno, EAGAIN, "errno=%d", errno); 375 376 RL(ret = poll(pfd, 2, 0)); 377 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 378 ATF_REQUIRE_EQ_MSG(pfd[0].revents, 0, 379 "pfd[0].revents=0x%x", pfd[0].revents); 380 ATF_REQUIRE_EQ_MSG(pfd[1].revents, POLLOUT|POLLWRNORM, 381 "pfd[1].revents=0x%x", pfd[1].revents); 382 383 RL(close(wfd)); 384 RL(close(rfd)); 385 } 386 387 ATF_TC_CLEANUP(fifo_inout, tc) 388 { 389 (void)unlink(fifo_path); 390 } 391 392 ATF_TC_WITH_CLEANUP(fifo_hup1); 393 ATF_TC_HEAD(fifo_hup1, tc) 394 { 395 atf_tc_set_md_var(tc, "descr", 396 "Check POLLHUP behavior with fifos [1]"); 397 } 398 399 ATF_TC_BODY(fifo_hup1, tc) 400 { 401 struct pollfd pfd; 402 int rfd, wfd; 403 int ret; 404 405 fifo_support(); 406 407 RL(mkfifo(fifo_path, 0600)); 408 RL(rfd = open(fifo_path, O_RDONLY | O_NONBLOCK)); 409 RL(wfd = open(fifo_path, O_WRONLY)); 410 411 memset(&pfd, 0, sizeof(pfd)); 412 pfd.fd = rfd; 413 pfd.events = POLLIN; 414 415 RL(close(wfd)); 416 417 RL(ret = poll(&pfd, 1, 0)); 418 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 419 ATF_REQUIRE_EQ_MSG((pfd.revents & (POLLHUP|POLLOUT)), POLLHUP, 420 "revents=0x%x expected POLLHUP=0x%x but not POLLOUT=0x%x", 421 pfd.revents, POLLHUP, POLLOUT); 422 423 /* 424 * Check that POLLHUP is cleared when a writer re-connects. 425 * Since the writer will not put any data into the FIFO, we 426 * expect no events. 427 */ 428 memset(&pfd, 0, sizeof(pfd)); 429 pfd.fd = rfd; 430 pfd.events = POLLIN; 431 432 RL(wfd = open(fifo_path, O_WRONLY)); 433 RL(ret = poll(&pfd, 1, 0)); 434 ATF_REQUIRE_EQ_MSG(ret, 0, "got: %d", ret); 435 } 436 437 ATF_TC_CLEANUP(fifo_hup1, tc) 438 { 439 (void)unlink(fifo_path); 440 } 441 442 ATF_TC_WITH_CLEANUP(fifo_hup2); 443 ATF_TC_HEAD(fifo_hup2, tc) 444 { 445 atf_tc_set_md_var(tc, "descr", 446 "Check POLLHUP behavior with fifos [2]"); 447 } 448 449 ATF_TC_BODY(fifo_hup2, tc) 450 { 451 struct pollfd pfd; 452 int rfd, wfd; 453 pid_t pid; 454 struct timespec ts1, ts2; 455 int ret; 456 457 fifo_support(); 458 459 RL(mkfifo(fifo_path, 0600)); 460 RL(rfd = open(fifo_path, O_RDONLY | O_NONBLOCK)); 461 RL(wfd = open(fifo_path, O_WRONLY)); 462 463 memset(&pfd, 0, sizeof(pfd)); 464 pfd.fd = rfd; 465 pfd.events = POLLIN; 466 467 RL(pid = fork()); 468 if (pid == 0) { 469 if (close(rfd)) 470 _exit(1); 471 sleep(5); 472 if (close(wfd)) 473 _exit(1); 474 _exit(0); 475 } 476 RL(close(wfd)); 477 478 RL(clock_gettime(CLOCK_MONOTONIC, &ts1)); 479 RL(ret = poll(&pfd, 1, INFTIM)); 480 ATF_REQUIRE_EQ_MSG(ret, 1, "got: %d", ret); 481 RL(clock_gettime(CLOCK_MONOTONIC, &ts2)); 482 483 /* Make sure at least a couple of seconds have elapsed. */ 484 ATF_REQUIRE_MSG(ts2.tv_sec - ts1.tv_sec >= 2, 485 "ts1=%lld.%09ld ts2=%lld.%09ld", 486 (long long)ts1.tv_sec, ts1.tv_nsec, 487 (long long)ts2.tv_sec, ts2.tv_nsec); 488 489 ATF_REQUIRE_EQ_MSG((pfd.revents & (POLLHUP|POLLOUT)), POLLHUP, 490 "revents=0x%x expected POLLHUP=0x%x but not POLLOUT=0x%x", 491 pfd.revents, POLLHUP, POLLOUT); 492 } 493 494 ATF_TC_CLEANUP(fifo_hup2, tc) 495 { 496 (void)unlink(fifo_path); 497 } 498 499 static void 500 fillpipebuf(int writefd) 501 { 502 char buf[BUFSIZ] = {0}; 503 size_t n = 0; 504 ssize_t nwrit; 505 int flags; 506 507 RL(flags = fcntl(writefd, F_GETFL)); 508 RL(fcntl(writefd, F_SETFL, flags|O_NONBLOCK)); 509 while ((nwrit = write(writefd, buf, sizeof(buf))) != -1) 510 n += (size_t)nwrit; 511 ATF_CHECK_EQ_MSG(errno, EAGAIN, "errno=%d", errno); 512 RL(fcntl(writefd, F_SETFL, flags)); 513 fprintf(stderr, "filled %d with %zu bytes\n", writefd, n); 514 } 515 516 static void 517 check_write_epipe(int writefd) 518 { 519 int flags; 520 void (*sighandler)(int); 521 char c = 0; 522 ssize_t nwrit; 523 524 RL(flags = fcntl(writefd, F_GETFL)); 525 RL(fcntl(writefd, F_SETFL, flags|O_NONBLOCK)); 526 527 REQUIRE_LIBC(sighandler = signal(SIGPIPE, SIG_IGN), SIG_ERR); 528 ATF_CHECK_ERRNO(EPIPE, (nwrit = write(writefd, &c, 1)) == -1); 529 ATF_CHECK_EQ_MSG(nwrit, -1, "nwrit=%zd", nwrit); 530 REQUIRE_LIBC(signal(SIGPIPE, sighandler), SIG_ERR); 531 532 RL(fcntl(writefd, F_SETFL, flags)); 533 } 534 535 static void 536 check_read_eof(int readfd) 537 { 538 int flags; 539 char c; 540 ssize_t nread; 541 542 RL(flags = fcntl(readfd, F_GETFL)); 543 RL(fcntl(readfd, F_SETFL, flags|O_NONBLOCK)); 544 545 RL(nread = read(readfd, &c, 1)); 546 ATF_CHECK_EQ_MSG(nread, 0, "nread=%zu", nread); 547 548 RL(fcntl(readfd, F_SETFL, flags)); 549 } 550 551 static void 552 check_pollclosed_delayed_write(int writefd, int readfd) 553 { 554 struct pollfd pfd = { .fd = writefd, .events = POLLOUT }; 555 struct timespec start, end, delta; 556 int nfds; 557 558 /* 559 * Don't let poll sleep for more than 3sec. (The close delay 560 * will be 2sec, and we make sure that we sleep at least 1sec.) 561 */ 562 REQUIRE_LIBC(alarm(3), (unsigned)-1); 563 564 /* 565 * Wait in poll(2) indefinitely (subject to the alarm) and 566 * measure how long we slept. 567 */ 568 fprintf(stderr, "poll %d\n", writefd); 569 RL(clock_gettime(CLOCK_MONOTONIC, &start)); 570 RL(nfds = poll(&pfd, 1, INFTIM)); 571 RL(clock_gettime(CLOCK_MONOTONIC, &end)); 572 fprintf(stderr, "poll %d done nfds=%d\n", writefd, nfds); 573 574 REQUIRE_LIBC(alarm(0), (unsigned)-1); 575 576 /* 577 * The reader has been closed, so write will fail immediately 578 * with EPIPE/SIGPIPE, and thus POLLOUT must be set. POLLHUP 579 * is only returned for reads, not for writes (and is mutually 580 * exclusive with POLLOUT). 581 */ 582 RL(nfds = poll(&pfd, 1, 0)); 583 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 584 ATF_CHECK_EQ_MSG(pfd.fd, writefd, "pfd.fd=%d writefd=%d", 585 pfd.fd, writefd); 586 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), POLLOUT, 587 "revents=0x%x expected POLLOUT=0x%x" 588 " but not POLLHUP=0x%x or POLLIN=0x%x", 589 pfd.revents, POLLOUT, POLLHUP, POLLIN); 590 591 /* 592 * We should have slept at least 1sec. 593 */ 594 timespecsub(&end, &start, &delta); 595 ATF_CHECK_MSG(delta.tv_sec >= 1, 596 "slept only %lld.%09ld", (long long)delta.tv_sec, delta.tv_nsec); 597 598 /* 599 * Write should fail with EPIPE/SIGPIPE now -- and continue to 600 * do so. 601 */ 602 check_write_epipe(writefd); 603 check_write_epipe(writefd); 604 } 605 606 static void 607 check_pollclosed_delayed_read(int readfd, int writefd, int pollhup) 608 { 609 struct pollfd pfd; 610 struct timespec start, end, delta; 611 int nfds; 612 613 /* 614 * Don't let poll sleep for more than 3sec. (The close delay 615 * will be 2sec, and we make sure that we sleep at least 1sec.) 616 */ 617 REQUIRE_LIBC(alarm(3), (unsigned)-1); 618 619 /* 620 * Wait in poll(2) indefinitely (subject to the alarm) and 621 * measure how long we slept. 622 */ 623 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 624 fprintf(stderr, "poll %d\n", readfd); 625 RL(clock_gettime(CLOCK_MONOTONIC, &start)); 626 RL(nfds = poll(&pfd, 1, INFTIM)); 627 RL(clock_gettime(CLOCK_MONOTONIC, &end)); 628 fprintf(stderr, "poll %d done nfds=%d\n", readfd, nfds); 629 630 REQUIRE_LIBC(alarm(0), (unsigned)-1); 631 632 /* 633 * Read will yield EOF without blocking, so POLLIN should be 634 * set, and the write side has been closed, so POLLHUP should 635 * also be set, unsolicited, if this is a pipe or FIFO -- but 636 * not if it's a socket, where POLLHUP is never set. Since we 637 * didn't ask for POLLOUT, it should be clear. 638 */ 639 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 640 ATF_CHECK_EQ_MSG(pfd.fd, readfd, "pfd.fd=%d readfd=%d writefd=%d", 641 pfd.fd, readfd, writefd); 642 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 643 pollhup|POLLIN, 644 "revents=0x%x expected=0x%x" 645 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 646 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 647 648 /* 649 * We should have slept at least 1sec. 650 */ 651 timespecsub(&end, &start, &delta); 652 ATF_CHECK_MSG(delta.tv_sec >= 1, 653 "slept only %lld.%09ld", (long long)delta.tv_sec, delta.tv_nsec); 654 655 /* 656 * Read should return EOF now -- and continue to do so. 657 */ 658 check_read_eof(readfd); 659 check_read_eof(readfd); 660 661 /* 662 * POLLHUP|POLLIN state should be persistent (until the writer 663 * side is reopened if possible, as in a named pipe). 664 */ 665 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 666 RL(nfds = poll(&pfd, 1, 0)); 667 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 668 ATF_CHECK_EQ_MSG(pfd.fd, readfd, "pfd.fd=%d readfd=%d writefd=%d", 669 pfd.fd, readfd, writefd); 670 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 671 pollhup|POLLIN, 672 "revents=0x%x expected=0x%x" 673 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 674 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 675 } 676 677 static void 678 check_pollclosed_delayed_read_pipefifo(int readfd, int writefd) 679 { 680 681 check_pollclosed_delayed_read(readfd, writefd, POLLHUP); 682 } 683 684 static void 685 check_pollclosed_delayed_read_socket(int readfd, int writefd) 686 { 687 688 check_pollclosed_delayed_read(readfd, writefd, /*no POLLHUP*/0); 689 } 690 691 static void 692 check_pollclosed_delayed_process(int pollfd, int closefd, 693 void (*check_pollhup)(int, int)) 694 { 695 pid_t pid; 696 int status; 697 698 /* 699 * Fork a child to close closefd after a 2sec delay. 700 */ 701 RL(pid = fork()); 702 if (pid == 0) { 703 sleep(2); 704 fprintf(stderr, "[child] close %d\n", closefd); 705 if (close(closefd) == -1) 706 _exit(1); 707 _exit(0); 708 } 709 710 /* 711 * Close closefd in the parent so the child has the last 712 * reference to it. 713 */ 714 fprintf(stderr, "[parent] close %d\n", closefd); 715 RL(close(closefd)); 716 717 /* 718 * Test poll(2). 719 */ 720 (*check_pollhup)(pollfd, closefd); 721 722 /* 723 * Wait for the child and make sure it exited successfully. 724 */ 725 RL(waitpid(pid, &status, 0)); 726 ATF_CHECK_EQ_MSG(status, 0, "child exited with status 0x%x", status); 727 } 728 729 static void * 730 check_pollclosed_thread(void *cookie) 731 { 732 int *closefdp = cookie; 733 734 sleep(2); 735 fprintf(stderr, "[thread] close %d\n", *closefdp); 736 RL(close(*closefdp)); 737 return NULL; 738 } 739 740 static void 741 check_pollclosed_delayed_thread(int pollfd, int closefd, 742 void (*check_pollhup)(int, int)) 743 { 744 pthread_t t; 745 746 /* 747 * Create a thread to close closefd (in this process, not a 748 * child) after a 2sec delay. 749 */ 750 RZ(pthread_create(&t, NULL, &check_pollclosed_thread, &closefd)); 751 752 /* 753 * Test poll(2). 754 */ 755 (*check_pollhup)(pollfd, closefd); 756 757 /* 758 * Wait for the thread to complete. 759 */ 760 RZ(pthread_join(t, NULL)); 761 } 762 763 static void 764 check_pollclosed_immediate_write(int writefd, int readfd) 765 { 766 struct pollfd pfd = { .fd = writefd, .events = POLLOUT }; 767 int nfds; 768 769 /* 770 * Close the reader side immediately. 771 */ 772 fprintf(stderr, "[immediate] close %d\n", readfd); 773 RL(close(readfd)); 774 775 /* 776 * The reader has been closed, so write will fail immediately 777 * with EPIPE/SIGPIPE, and thus POLLOUT must be set. POLLHUP 778 * is only returned for reads, not for writes (and is mutually 779 * exclusive with POLLOUT). 780 */ 781 RL(nfds = poll(&pfd, 1, 0)); 782 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 783 ATF_CHECK_EQ_MSG(pfd.fd, writefd, "pfd.fd=%d writefd=%d", 784 pfd.fd, writefd); 785 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), POLLOUT, 786 "revents=0x%x expected POLLOUT=0x%x" 787 " but not POLLHUP=0x%x or POLLIN=0x%x", 788 pfd.revents, POLLOUT, POLLHUP, POLLIN); 789 790 /* 791 * Write should fail with EPIPE/SIGPIPE now -- and continue to 792 * do so. 793 */ 794 check_write_epipe(writefd); 795 check_write_epipe(writefd); 796 } 797 798 static void 799 check_pollclosed_immediate_readnone(int readfd, int writefd, int pollhup) 800 { 801 struct pollfd pfd = { .fd = readfd, .events = POLLIN }; 802 int nfds; 803 804 /* 805 * Close the writer side immediately. 806 */ 807 fprintf(stderr, "[immediate] close %d\n", writefd); 808 RL(close(writefd)); 809 810 /* 811 * Read will yield EOF without blocking, so POLLIN should be 812 * set, and the write side has been closed, so POLLHUP should 813 * be set, unsolicited, if this is a pipe or FIFO -- but not if 814 * it's a socket, where POLLHUP is never set. Since we didn't 815 * ask for POLLOUT, it should be clear. 816 */ 817 RL(nfds = poll(&pfd, 1, 0)); 818 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 819 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 820 pollhup|POLLIN, 821 "revents=0x%x expected=0x%x" 822 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 823 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 824 825 /* 826 * Read should return EOF now -- and continue to do so. 827 */ 828 check_read_eof(readfd); 829 check_read_eof(readfd); 830 } 831 832 static void 833 check_pollclosed_immediate_readsome(int readfd, int writefd, int pollhup) 834 { 835 struct pollfd pfd; 836 char buf[BUFSIZ]; 837 ssize_t nread; 838 int nfds; 839 840 /* 841 * Close the writer side immediately. 842 */ 843 fprintf(stderr, "[immediate] close %d\n", writefd); 844 RL(close(writefd)); 845 846 /* 847 * Some data should be ready to read, so POLLIN should be set, 848 * and the write side has been closed, so POLLHUP should also 849 * be set, unsolicited, if this is a pipe or FIFO -- but not if 850 * it's a socket, where POLLHUP is never set. Since we didn't 851 * ask for POLLOUT, it should be clear. 852 */ 853 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 854 RL(nfds = poll(&pfd, 1, 0)); 855 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 856 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 857 POLLIN|pollhup, 858 "revents=0x%x expected=0x%x" 859 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 860 pfd.revents, POLLIN|pollhup, POLLHUP, POLLIN, POLLOUT); 861 862 /* 863 * Read all the data. Each read should complete instantly -- 864 * no blocking, either because there's data to read or because 865 * the writer has hung up and we get EOF. 866 */ 867 do { 868 REQUIRE_LIBC(alarm(1), (unsigned)-1); 869 RL(nread = read(readfd, buf, sizeof(buf))); 870 REQUIRE_LIBC(alarm(0), (unsigned)-1); 871 } while (nread != 0); 872 873 /* 874 * Read will yield EOF without blocking, so POLLIN should be 875 * set, and the write side has been closed, so POLLHUP should 876 * also be set, unsolicited, if this is a pipe or FIFO -- but 877 * not if it's a socket, where POLLHUP is never set. Since we 878 * didn't ask for POLLOUT, it should be clear. 879 */ 880 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 881 RL(nfds = poll(&pfd, 1, 0)); 882 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 883 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 884 pollhup|POLLIN, 885 "revents=0x%x expected=0x%x" 886 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 887 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 888 889 /* 890 * Read should return EOF now -- and continue to do so. 891 */ 892 check_read_eof(readfd); 893 check_read_eof(readfd); 894 895 /* 896 * POLLHUP|POLLIN state should be persistent (until the writer 897 * side is reopened if possible, as in a named pipe). 898 */ 899 pfd = (struct pollfd) { .fd = readfd, .events = POLLIN }; 900 RL(nfds = poll(&pfd, 1, 0)); 901 ATF_CHECK_EQ_MSG(nfds, 1, "nfds=%d", nfds); 902 ATF_CHECK_EQ_MSG((pfd.revents & (POLLHUP|POLLIN|POLLOUT)), 903 pollhup|POLLIN, 904 "revents=0x%x expected=0x%x" 905 " POLLHUP=0x%x POLLIN=0x%x POLLOUT=0x%x", 906 pfd.revents, pollhup|POLLIN, POLLHUP, POLLIN, POLLOUT); 907 } 908 909 static void * 910 pollclosed_fifo_writer_thread(void *cookie) 911 { 912 int *pp = cookie; 913 914 RL(*pp = open(fifo_path, O_WRONLY)); 915 return NULL; 916 } 917 918 static void * 919 pollclosed_fifo_reader_thread(void *cookie) 920 { 921 int *pp = cookie; 922 923 RL(*pp = open(fifo_path, O_RDONLY)); 924 return NULL; 925 } 926 927 static void 928 pollclosed_fifo0_setup(int *writefdp, int *readfdp) 929 { 930 int p0, p1; 931 pthread_t t; 932 933 fifo_support(); 934 935 RL(mkfifo(fifo_path, 0600)); 936 RZ(pthread_create(&t, NULL, &pollclosed_fifo_reader_thread, &p0)); 937 REQUIRE_LIBC(alarm(1), (unsigned)-1); 938 RL(p1 = open(fifo_path, O_WRONLY)); 939 REQUIRE_LIBC(alarm(0), (unsigned)-1); 940 RZ(pthread_join(t, NULL)); 941 942 *writefdp = p1; 943 *readfdp = p0; 944 } 945 946 static void 947 pollclosed_fifo1_setup(int *writefdp, int *readfdp) 948 { 949 int p0, p1; 950 pthread_t t; 951 952 fifo_support(); 953 954 RL(mkfifo(fifo_path, 0600)); 955 RZ(pthread_create(&t, NULL, &pollclosed_fifo_writer_thread, &p0)); 956 REQUIRE_LIBC(alarm(1), (unsigned)-1); 957 RL(p1 = open(fifo_path, O_RDONLY)); 958 REQUIRE_LIBC(alarm(0), (unsigned)-1); 959 RZ(pthread_join(t, NULL)); 960 961 *writefdp = p0; 962 *readfdp = p1; 963 } 964 965 static void 966 pollclosed_pipe_setup(int *writefdp, int *readfdp) 967 { 968 int p[2]; 969 970 RL(pipe(p)); 971 972 *readfdp = p[0]; /* reader side */ 973 *writefdp = p[1]; /* writer side */ 974 } 975 976 static void 977 pollclosed_socketpair0_setup(int *writefdp, int *readfdp) 978 { 979 int s[2]; 980 981 RL(socketpair(AF_LOCAL, SOCK_STREAM, 0, s)); 982 *readfdp = s[0]; 983 *writefdp = s[1]; 984 } 985 986 static void 987 pollclosed_socketpair1_setup(int *writefdp, int *readfdp) 988 { 989 int s[2]; 990 991 RL(socketpair(AF_LOCAL, SOCK_STREAM, 0, s)); 992 *readfdp = s[1]; 993 *writefdp = s[0]; 994 } 995 996 /* 997 * Cartesian product of: 998 * 999 * 1. [fifo0] first fifo opener 1000 * 2. [fifo1] second fifo opener 1001 * 3. [pipe] pipe 1002 * 4. [socketpair0] first side of socket pair 1003 * 5. [socketpair1] second side of socket pair 1004 * 1005 * with 1006 * 1007 * 1. [immediate] closed before poll starts 1008 * 2. [delayed_thread] closed by another thread after poll starts 1009 * 3. [delayed_process] closed by another process after poll starts 1010 * 1011 * with 1012 * 1013 * 1. [writefull] close reader, poll for write when buffer full 1014 * 2. [writeempty] close reader, poll for write when buffer empty 1015 * 3. [readnone] close writer, poll for read when nothing to read 1016 * 4. [readsome] close writer, poll for read when something to read 1017 * 1018 * except that in the delayed cases we only do writefull [write] and 1019 * readnone [read], because there's no delay in the writeempty/readsome 1020 * cases. 1021 */ 1022 1023 ATF_TC(pollclosed_fifo0_immediate_writefull); 1024 ATF_TC_HEAD(pollclosed_fifo0_immediate_writefull, tc) 1025 { 1026 atf_tc_set_md_var(tc, "descr", 1027 "Checks POLLHUP with closing the first opener of a named pipe"); 1028 } 1029 ATF_TC_BODY(pollclosed_fifo0_immediate_writefull, tc) 1030 { 1031 int writefd, readfd; 1032 1033 pollclosed_fifo0_setup(&writefd, &readfd); 1034 fillpipebuf(writefd); 1035 check_pollclosed_immediate_write(writefd, readfd); 1036 } 1037 1038 ATF_TC(pollclosed_fifo0_immediate_writeempty); 1039 ATF_TC_HEAD(pollclosed_fifo0_immediate_writeempty, tc) 1040 { 1041 atf_tc_set_md_var(tc, "descr", 1042 "Checks POLLHUP with closing the first opener of a named pipe"); 1043 } 1044 ATF_TC_BODY(pollclosed_fifo0_immediate_writeempty, tc) 1045 { 1046 int writefd, readfd; 1047 1048 pollclosed_fifo0_setup(&writefd, &readfd); 1049 /* don't fill the pipe buf */ 1050 check_pollclosed_immediate_write(writefd, readfd); 1051 } 1052 1053 ATF_TC(pollclosed_fifo0_immediate_readsome); 1054 ATF_TC_HEAD(pollclosed_fifo0_immediate_readsome, tc) 1055 { 1056 atf_tc_set_md_var(tc, "descr", 1057 "Checks POLLHUP with closing the first opener of a named pipe"); 1058 } 1059 ATF_TC_BODY(pollclosed_fifo0_immediate_readsome, tc) 1060 { 1061 int writefd, readfd; 1062 1063 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1064 1065 pollclosed_fifo1_setup(&writefd, &readfd); 1066 fillpipebuf(writefd); 1067 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1068 } 1069 1070 ATF_TC(pollclosed_fifo0_immediate_readnone); 1071 ATF_TC_HEAD(pollclosed_fifo0_immediate_readnone, tc) 1072 { 1073 atf_tc_set_md_var(tc, "descr", 1074 "Checks POLLHUP with closing the first opener of a named pipe"); 1075 } 1076 ATF_TC_BODY(pollclosed_fifo0_immediate_readnone, tc) 1077 { 1078 int writefd, readfd; 1079 1080 pollclosed_fifo1_setup(&writefd, &readfd); 1081 /* don't fill the pipe buf */ 1082 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1083 } 1084 1085 ATF_TC(pollclosed_fifo0_delayed_process_write); 1086 ATF_TC_HEAD(pollclosed_fifo0_delayed_process_write, tc) 1087 { 1088 atf_tc_set_md_var(tc, "descr", 1089 "Checks POLLHUP with closing the first opener of a named pipe"); 1090 } 1091 ATF_TC_BODY(pollclosed_fifo0_delayed_process_write, tc) 1092 { 1093 int writefd, readfd; 1094 1095 pollclosed_fifo0_setup(&writefd, &readfd); 1096 fillpipebuf(writefd); 1097 check_pollclosed_delayed_process(writefd, readfd, 1098 &check_pollclosed_delayed_write); 1099 } 1100 1101 ATF_TC(pollclosed_fifo0_delayed_process_read); 1102 ATF_TC_HEAD(pollclosed_fifo0_delayed_process_read, tc) 1103 { 1104 atf_tc_set_md_var(tc, "descr", 1105 "Checks POLLHUP with closing the first opener of a named pipe"); 1106 } 1107 ATF_TC_BODY(pollclosed_fifo0_delayed_process_read, tc) 1108 { 1109 int writefd, readfd; 1110 1111 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1112 1113 pollclosed_fifo1_setup(&writefd, &readfd); 1114 /* don't fill pipe buf */ 1115 check_pollclosed_delayed_process(readfd, writefd, 1116 &check_pollclosed_delayed_read_pipefifo); 1117 } 1118 1119 ATF_TC(pollclosed_fifo0_delayed_thread_write); 1120 ATF_TC_HEAD(pollclosed_fifo0_delayed_thread_write, tc) 1121 { 1122 atf_tc_set_md_var(tc, "descr", 1123 "Checks POLLHUP with closing the first opener of a named pipe"); 1124 } 1125 ATF_TC_BODY(pollclosed_fifo0_delayed_thread_write, tc) 1126 { 1127 int writefd, readfd; 1128 1129 pollclosed_fifo0_setup(&writefd, &readfd); 1130 fillpipebuf(writefd); 1131 check_pollclosed_delayed_thread(writefd, readfd, 1132 &check_pollclosed_delayed_write); 1133 } 1134 1135 ATF_TC(pollclosed_fifo0_delayed_thread_read); 1136 ATF_TC_HEAD(pollclosed_fifo0_delayed_thread_read, tc) 1137 { 1138 atf_tc_set_md_var(tc, "descr", 1139 "Checks POLLHUP with closing the first opener of a named pipe"); 1140 } 1141 ATF_TC_BODY(pollclosed_fifo0_delayed_thread_read, tc) 1142 { 1143 int writefd, readfd; 1144 1145 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1146 1147 pollclosed_fifo1_setup(&writefd, &readfd); 1148 /* don't fill pipe buf */ 1149 check_pollclosed_delayed_thread(readfd, writefd, 1150 &check_pollclosed_delayed_read_pipefifo); 1151 } 1152 1153 ATF_TC(pollclosed_fifo1_immediate_writefull); 1154 ATF_TC_HEAD(pollclosed_fifo1_immediate_writefull, tc) 1155 { 1156 atf_tc_set_md_var(tc, "descr", 1157 "Checks POLLHUP with closing the second opener of a named pipe"); 1158 } 1159 ATF_TC_BODY(pollclosed_fifo1_immediate_writefull, tc) 1160 { 1161 int writefd, readfd; 1162 1163 pollclosed_fifo1_setup(&writefd, &readfd); 1164 fillpipebuf(writefd); 1165 check_pollclosed_immediate_write(writefd, readfd); 1166 } 1167 1168 ATF_TC(pollclosed_fifo1_immediate_writeempty); 1169 ATF_TC_HEAD(pollclosed_fifo1_immediate_writeempty, tc) 1170 { 1171 atf_tc_set_md_var(tc, "descr", 1172 "Checks POLLHUP with closing the second opener of a named pipe"); 1173 } 1174 ATF_TC_BODY(pollclosed_fifo1_immediate_writeempty, tc) 1175 { 1176 int writefd, readfd; 1177 1178 pollclosed_fifo1_setup(&writefd, &readfd); 1179 /* don't fill the pipe buf */ 1180 check_pollclosed_immediate_write(writefd, readfd); 1181 } 1182 1183 ATF_TC(pollclosed_fifo1_immediate_readsome); 1184 ATF_TC_HEAD(pollclosed_fifo1_immediate_readsome, tc) 1185 { 1186 atf_tc_set_md_var(tc, "descr", 1187 "Checks POLLHUP with closing the second opener of a named pipe"); 1188 } 1189 ATF_TC_BODY(pollclosed_fifo1_immediate_readsome, tc) 1190 { 1191 int writefd, readfd; 1192 1193 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1194 1195 pollclosed_fifo1_setup(&writefd, &readfd); 1196 fillpipebuf(writefd); 1197 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1198 } 1199 1200 ATF_TC(pollclosed_fifo1_immediate_readnone); 1201 ATF_TC_HEAD(pollclosed_fifo1_immediate_readnone, tc) 1202 { 1203 atf_tc_set_md_var(tc, "descr", 1204 "Checks POLLHUP with closing the second opener of a named pipe"); 1205 } 1206 ATF_TC_BODY(pollclosed_fifo1_immediate_readnone, tc) 1207 { 1208 int writefd, readfd; 1209 1210 pollclosed_fifo1_setup(&writefd, &readfd); 1211 /* don't fill the pipe buf */ 1212 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1213 } 1214 1215 ATF_TC(pollclosed_fifo1_delayed_process_write); 1216 ATF_TC_HEAD(pollclosed_fifo1_delayed_process_write, tc) 1217 { 1218 atf_tc_set_md_var(tc, "descr", 1219 "Checks POLLHUP with closing the second opener of a named pipe"); 1220 } 1221 ATF_TC_BODY(pollclosed_fifo1_delayed_process_write, tc) 1222 { 1223 int writefd, readfd; 1224 1225 pollclosed_fifo1_setup(&writefd, &readfd); 1226 fillpipebuf(writefd); 1227 check_pollclosed_delayed_process(writefd, readfd, 1228 &check_pollclosed_delayed_write); 1229 } 1230 1231 ATF_TC(pollclosed_fifo1_delayed_process_read); 1232 ATF_TC_HEAD(pollclosed_fifo1_delayed_process_read, 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_delayed_process_read, tc) 1238 { 1239 int writefd, readfd; 1240 1241 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1242 1243 pollclosed_fifo0_setup(&writefd, &readfd); 1244 /* don't fill pipe buf */ 1245 check_pollclosed_delayed_process(readfd, writefd, 1246 &check_pollclosed_delayed_read_pipefifo); 1247 } 1248 1249 ATF_TC(pollclosed_fifo1_delayed_thread_write); 1250 ATF_TC_HEAD(pollclosed_fifo1_delayed_thread_write, tc) 1251 { 1252 atf_tc_set_md_var(tc, "descr", 1253 "Checks POLLHUP with closing the second opener of a named pipe"); 1254 } 1255 ATF_TC_BODY(pollclosed_fifo1_delayed_thread_write, tc) 1256 { 1257 int writefd, readfd; 1258 1259 pollclosed_fifo1_setup(&writefd, &readfd); 1260 fillpipebuf(writefd); 1261 check_pollclosed_delayed_thread(writefd, readfd, 1262 &check_pollclosed_delayed_write); 1263 } 1264 1265 ATF_TC(pollclosed_fifo1_delayed_thread_read); 1266 ATF_TC_HEAD(pollclosed_fifo1_delayed_thread_read, tc) 1267 { 1268 atf_tc_set_md_var(tc, "descr", 1269 "Checks POLLHUP with closing the second opener of a named pipe"); 1270 } 1271 ATF_TC_BODY(pollclosed_fifo1_delayed_thread_read, tc) 1272 { 1273 int writefd, readfd; 1274 1275 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1276 1277 pollclosed_fifo0_setup(&writefd, &readfd); 1278 /* don't fill pipe buf */ 1279 check_pollclosed_delayed_process(readfd, writefd, 1280 &check_pollclosed_delayed_read_pipefifo); 1281 } 1282 1283 ATF_TC(pollclosed_pipe_immediate_writefull); 1284 ATF_TC_HEAD(pollclosed_pipe_immediate_writefull, tc) 1285 { 1286 atf_tc_set_md_var(tc, "descr", 1287 "Checks POLLHUP with a closed pipe"); 1288 } 1289 ATF_TC_BODY(pollclosed_pipe_immediate_writefull, tc) 1290 { 1291 int writefd, readfd; 1292 1293 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1294 1295 pollclosed_pipe_setup(&writefd, &readfd); 1296 fillpipebuf(writefd); 1297 check_pollclosed_immediate_write(writefd, readfd); 1298 } 1299 1300 ATF_TC(pollclosed_pipe_immediate_writeempty); 1301 ATF_TC_HEAD(pollclosed_pipe_immediate_writeempty, tc) 1302 { 1303 atf_tc_set_md_var(tc, "descr", 1304 "Checks POLLHUP with a closed pipe"); 1305 } 1306 ATF_TC_BODY(pollclosed_pipe_immediate_writeempty, tc) 1307 { 1308 int writefd, readfd; 1309 1310 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1311 1312 pollclosed_pipe_setup(&writefd, &readfd); 1313 /* don't fill pipe buf */ 1314 check_pollclosed_immediate_write(writefd, readfd); 1315 } 1316 1317 ATF_TC(pollclosed_pipe_immediate_readsome); 1318 ATF_TC_HEAD(pollclosed_pipe_immediate_readsome, tc) 1319 { 1320 atf_tc_set_md_var(tc, "descr", 1321 "Checks POLLHUP with a closed pipe"); 1322 } 1323 ATF_TC_BODY(pollclosed_pipe_immediate_readsome, tc) 1324 { 1325 int writefd, readfd; 1326 1327 pollclosed_pipe_setup(&writefd, &readfd); 1328 fillpipebuf(writefd); 1329 check_pollclosed_immediate_readsome(readfd, writefd, POLLHUP); 1330 } 1331 1332 ATF_TC(pollclosed_pipe_immediate_readnone); 1333 ATF_TC_HEAD(pollclosed_pipe_immediate_readnone, tc) 1334 { 1335 atf_tc_set_md_var(tc, "descr", 1336 "Checks POLLHUP with a closed pipe"); 1337 } 1338 ATF_TC_BODY(pollclosed_pipe_immediate_readnone, tc) 1339 { 1340 int writefd, readfd; 1341 1342 pollclosed_pipe_setup(&writefd, &readfd); 1343 /* don't fill pipe buf */ 1344 check_pollclosed_immediate_readnone(readfd, writefd, POLLHUP); 1345 } 1346 1347 ATF_TC(pollclosed_pipe_delayed_process_write); 1348 ATF_TC_HEAD(pollclosed_pipe_delayed_process_write, tc) 1349 { 1350 atf_tc_set_md_var(tc, "descr", 1351 "Checks POLLHUP with a closed pipe"); 1352 } 1353 ATF_TC_BODY(pollclosed_pipe_delayed_process_write, tc) 1354 { 1355 int writefd, readfd; 1356 1357 atf_tc_expect_fail("PR kern/59056: poll POLLHUP bugs"); 1358 1359 pollclosed_pipe_setup(&writefd, &readfd); 1360 fillpipebuf(writefd); 1361 check_pollclosed_delayed_process(writefd, readfd, 1362 &check_pollclosed_delayed_write); 1363 } 1364 1365 ATF_TC(pollclosed_pipe_delayed_process_read); 1366 ATF_TC_HEAD(pollclosed_pipe_delayed_process_read, tc) 1367 { 1368 atf_tc_set_md_var(tc, "descr", 1369 "Checks POLLHUP with a closed pipe"); 1370 } 1371 ATF_TC_BODY(pollclosed_pipe_delayed_process_read, tc) 1372 { 1373 int writefd, readfd; 1374 1375 pollclosed_pipe_setup(&writefd, &readfd); 1376 /* don't fill pipe buf */ 1377 check_pollclosed_delayed_process(readfd, writefd, 1378 &check_pollclosed_delayed_read_pipefifo); 1379 } 1380 1381 ATF_TC(pollclosed_pipe_delayed_thread_write); 1382 ATF_TC_HEAD(pollclosed_pipe_delayed_thread_write, tc) 1383 { 1384 atf_tc_set_md_var(tc, "descr", 1385 "Checks POLLHUP with a closed pipe"); 1386 } 1387 ATF_TC_BODY(pollclosed_pipe_delayed_thread_write, tc) 1388 { 1389 int writefd, readfd; 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_delayed_thread(writefd, readfd, 1396 &check_pollclosed_delayed_write); 1397 } 1398 1399 ATF_TC(pollclosed_pipe_delayed_thread_read); 1400 ATF_TC_HEAD(pollclosed_pipe_delayed_thread_read, tc) 1401 { 1402 atf_tc_set_md_var(tc, "descr", 1403 "Checks POLLHUP with a closed pipe"); 1404 } 1405 ATF_TC_BODY(pollclosed_pipe_delayed_thread_read, tc) 1406 { 1407 int writefd, readfd; 1408 1409 pollclosed_pipe_setup(&writefd, &readfd); 1410 /* don't fill pipe buf */ 1411 check_pollclosed_delayed_thread(readfd, writefd, 1412 &check_pollclosed_delayed_read_pipefifo); 1413 } 1414 1415 ATF_TC(pollclosed_socketpair0_immediate_writefull); 1416 ATF_TC_HEAD(pollclosed_socketpair0_immediate_writefull, tc) 1417 { 1418 atf_tc_set_md_var(tc, "descr", 1419 "Checks POLLHUP with closing the first half of a socketpair"); 1420 } 1421 ATF_TC_BODY(pollclosed_socketpair0_immediate_writefull, tc) 1422 { 1423 int writefd, readfd; 1424 1425 pollclosed_socketpair0_setup(&writefd, &readfd); 1426 fillpipebuf(writefd); 1427 check_pollclosed_immediate_write(writefd, readfd); 1428 } 1429 1430 ATF_TC(pollclosed_socketpair0_immediate_writeempty); 1431 ATF_TC_HEAD(pollclosed_socketpair0_immediate_writeempty, tc) 1432 { 1433 atf_tc_set_md_var(tc, "descr", 1434 "Checks POLLHUP with closing the first half of a socketpair"); 1435 } 1436 ATF_TC_BODY(pollclosed_socketpair0_immediate_writeempty, tc) 1437 { 1438 int writefd, readfd; 1439 1440 pollclosed_socketpair0_setup(&writefd, &readfd); 1441 /* don't fill the pipe buf */ 1442 check_pollclosed_immediate_write(writefd, readfd); 1443 } 1444 1445 ATF_TC(pollclosed_socketpair0_immediate_readsome); 1446 ATF_TC_HEAD(pollclosed_socketpair0_immediate_readsome, tc) 1447 { 1448 atf_tc_set_md_var(tc, "descr", 1449 "Checks POLLHUP with closing the first half of a socketpair"); 1450 } 1451 ATF_TC_BODY(pollclosed_socketpair0_immediate_readsome, tc) 1452 { 1453 int writefd, readfd; 1454 1455 pollclosed_socketpair1_setup(&writefd, &readfd); 1456 fillpipebuf(writefd); 1457 check_pollclosed_immediate_readsome(readfd, writefd, /*no POLLHUP*/0); 1458 } 1459 1460 ATF_TC(pollclosed_socketpair0_immediate_readnone); 1461 ATF_TC_HEAD(pollclosed_socketpair0_immediate_readnone, tc) 1462 { 1463 atf_tc_set_md_var(tc, "descr", 1464 "Checks POLLHUP with closing the first half of a socketpair"); 1465 } 1466 ATF_TC_BODY(pollclosed_socketpair0_immediate_readnone, tc) 1467 { 1468 int writefd, readfd; 1469 1470 pollclosed_socketpair1_setup(&writefd, &readfd); 1471 /* don't fill the pipe buf */ 1472 check_pollclosed_immediate_readnone(readfd, writefd, /*no POLLHUP*/0); 1473 } 1474 1475 ATF_TC(pollclosed_socketpair0_delayed_process_write); 1476 ATF_TC_HEAD(pollclosed_socketpair0_delayed_process_write, tc) 1477 { 1478 atf_tc_set_md_var(tc, "descr", 1479 "Checks POLLHUP with closing the first half of a socketpair"); 1480 } 1481 ATF_TC_BODY(pollclosed_socketpair0_delayed_process_write, tc) 1482 { 1483 int writefd, readfd; 1484 1485 pollclosed_socketpair0_setup(&writefd, &readfd); 1486 fillpipebuf(writefd); 1487 check_pollclosed_delayed_process(writefd, readfd, 1488 &check_pollclosed_delayed_write); 1489 } 1490 1491 ATF_TC(pollclosed_socketpair0_delayed_process_read); 1492 ATF_TC_HEAD(pollclosed_socketpair0_delayed_process_read, tc) 1493 { 1494 atf_tc_set_md_var(tc, "descr", 1495 "Checks POLLHUP with closing the first half of a socketpair"); 1496 } 1497 ATF_TC_BODY(pollclosed_socketpair0_delayed_process_read, tc) 1498 { 1499 int writefd, readfd; 1500 1501 pollclosed_socketpair1_setup(&writefd, &readfd); 1502 /* don't fill pipe buf */ 1503 check_pollclosed_delayed_process(readfd, writefd, 1504 &check_pollclosed_delayed_read_socket); 1505 } 1506 1507 ATF_TC(pollclosed_socketpair0_delayed_thread_write); 1508 ATF_TC_HEAD(pollclosed_socketpair0_delayed_thread_write, tc) 1509 { 1510 atf_tc_set_md_var(tc, "descr", 1511 "Checks POLLHUP with closing the first half of a socketpair"); 1512 } 1513 ATF_TC_BODY(pollclosed_socketpair0_delayed_thread_write, tc) 1514 { 1515 int writefd, readfd; 1516 1517 pollclosed_socketpair0_setup(&writefd, &readfd); 1518 fillpipebuf(writefd); 1519 check_pollclosed_delayed_thread(writefd, readfd, 1520 &check_pollclosed_delayed_write); 1521 } 1522 1523 ATF_TC(pollclosed_socketpair0_delayed_thread_read); 1524 ATF_TC_HEAD(pollclosed_socketpair0_delayed_thread_read, tc) 1525 { 1526 atf_tc_set_md_var(tc, "descr", 1527 "Checks POLLHUP with closing the first half of a socketpair"); 1528 } 1529 ATF_TC_BODY(pollclosed_socketpair0_delayed_thread_read, tc) 1530 { 1531 int writefd, readfd; 1532 1533 pollclosed_socketpair1_setup(&writefd, &readfd); 1534 /* don't fill pipe buf */ 1535 check_pollclosed_delayed_thread(readfd, writefd, 1536 &check_pollclosed_delayed_read_socket); 1537 } 1538 1539 ATF_TC(pollclosed_socketpair1_immediate_writefull); 1540 ATF_TC_HEAD(pollclosed_socketpair1_immediate_writefull, tc) 1541 { 1542 atf_tc_set_md_var(tc, "descr", 1543 "Checks POLLHUP with closing the second half of a socketpair"); 1544 } 1545 ATF_TC_BODY(pollclosed_socketpair1_immediate_writefull, tc) 1546 { 1547 int writefd, readfd; 1548 1549 pollclosed_socketpair1_setup(&writefd, &readfd); 1550 fillpipebuf(writefd); 1551 check_pollclosed_immediate_write(writefd, readfd); 1552 } 1553 1554 ATF_TC(pollclosed_socketpair1_immediate_writeempty); 1555 ATF_TC_HEAD(pollclosed_socketpair1_immediate_writeempty, tc) 1556 { 1557 atf_tc_set_md_var(tc, "descr", 1558 "Checks POLLHUP with closing the second half of a socketpair"); 1559 } 1560 ATF_TC_BODY(pollclosed_socketpair1_immediate_writeempty, tc) 1561 { 1562 int writefd, readfd; 1563 1564 pollclosed_socketpair1_setup(&writefd, &readfd); 1565 /* don't fill the pipe buf */ 1566 check_pollclosed_immediate_write(writefd, readfd); 1567 } 1568 1569 ATF_TC(pollclosed_socketpair1_immediate_readsome); 1570 ATF_TC_HEAD(pollclosed_socketpair1_immediate_readsome, tc) 1571 { 1572 atf_tc_set_md_var(tc, "descr", 1573 "Checks POLLHUP with closing the second half of a socketpair"); 1574 } 1575 ATF_TC_BODY(pollclosed_socketpair1_immediate_readsome, tc) 1576 { 1577 int writefd, readfd; 1578 1579 pollclosed_socketpair0_setup(&writefd, &readfd); 1580 fillpipebuf(writefd); 1581 check_pollclosed_immediate_readsome(readfd, writefd, /*no POLLHUP*/0); 1582 } 1583 1584 ATF_TC(pollclosed_socketpair1_immediate_readnone); 1585 ATF_TC_HEAD(pollclosed_socketpair1_immediate_readnone, tc) 1586 { 1587 atf_tc_set_md_var(tc, "descr", 1588 "Checks POLLHUP with closing the second half of a socketpair"); 1589 } 1590 ATF_TC_BODY(pollclosed_socketpair1_immediate_readnone, tc) 1591 { 1592 int writefd, readfd; 1593 1594 pollclosed_socketpair0_setup(&writefd, &readfd); 1595 /* don't fill the pipe buf */ 1596 check_pollclosed_immediate_readnone(readfd, writefd, /*no POLLHUP*/0); 1597 } 1598 1599 ATF_TC(pollclosed_socketpair1_delayed_process_write); 1600 ATF_TC_HEAD(pollclosed_socketpair1_delayed_process_write, tc) 1601 { 1602 atf_tc_set_md_var(tc, "descr", 1603 "Checks POLLHUP with closing the second half of a socketpair"); 1604 } 1605 ATF_TC_BODY(pollclosed_socketpair1_delayed_process_write, tc) 1606 { 1607 int writefd, readfd; 1608 1609 pollclosed_socketpair1_setup(&writefd, &readfd); 1610 fillpipebuf(writefd); 1611 check_pollclosed_delayed_process(writefd, readfd, 1612 &check_pollclosed_delayed_write); 1613 } 1614 1615 ATF_TC(pollclosed_socketpair1_delayed_process_read); 1616 ATF_TC_HEAD(pollclosed_socketpair1_delayed_process_read, tc) 1617 { 1618 atf_tc_set_md_var(tc, "descr", 1619 "Checks POLLHUP with closing the second half of a socketpair"); 1620 } 1621 ATF_TC_BODY(pollclosed_socketpair1_delayed_process_read, tc) 1622 { 1623 int writefd, readfd; 1624 1625 pollclosed_socketpair0_setup(&writefd, &readfd); 1626 /* don't fill pipe buf */ 1627 check_pollclosed_delayed_process(readfd, writefd, 1628 &check_pollclosed_delayed_read_socket); 1629 } 1630 1631 ATF_TC(pollclosed_socketpair1_delayed_thread_write); 1632 ATF_TC_HEAD(pollclosed_socketpair1_delayed_thread_write, tc) 1633 { 1634 atf_tc_set_md_var(tc, "descr", 1635 "Checks POLLHUP with closing the second half of a socketpair"); 1636 } 1637 ATF_TC_BODY(pollclosed_socketpair1_delayed_thread_write, tc) 1638 { 1639 int writefd, readfd; 1640 1641 pollclosed_socketpair1_setup(&writefd, &readfd); 1642 fillpipebuf(writefd); 1643 check_pollclosed_delayed_thread(writefd, readfd, 1644 &check_pollclosed_delayed_write); 1645 } 1646 1647 ATF_TC(pollclosed_socketpair1_delayed_thread_read); 1648 ATF_TC_HEAD(pollclosed_socketpair1_delayed_thread_read, tc) 1649 { 1650 atf_tc_set_md_var(tc, "descr", 1651 "Checks POLLHUP with closing the second half of a socketpair"); 1652 } 1653 ATF_TC_BODY(pollclosed_socketpair1_delayed_thread_read, tc) 1654 { 1655 int writefd, readfd; 1656 1657 pollclosed_socketpair0_setup(&writefd, &readfd); 1658 /* don't fill pipe buf */ 1659 check_pollclosed_delayed_process(readfd, writefd, 1660 &check_pollclosed_delayed_read_socket); 1661 } 1662 1663 ATF_TP_ADD_TCS(tp) 1664 { 1665 1666 ATF_TP_ADD_TC(tp, 3way); 1667 ATF_TP_ADD_TC(tp, basic); 1668 ATF_TP_ADD_TC(tp, err); 1669 1670 ATF_TP_ADD_TC(tp, fifo_inout); 1671 ATF_TP_ADD_TC(tp, fifo_hup1); 1672 ATF_TP_ADD_TC(tp, fifo_hup2); 1673 1674 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_writefull); 1675 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_writefull); 1676 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_writefull); 1677 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_writefull); 1678 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_writefull); 1679 1680 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_writeempty); 1681 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_writeempty); 1682 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_writeempty); 1683 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_writeempty); 1684 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_writeempty); 1685 1686 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_readsome); 1687 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_readsome); 1688 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_readsome); 1689 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_readsome); 1690 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_readsome); 1691 1692 ATF_TP_ADD_TC(tp, pollclosed_fifo0_immediate_readnone); 1693 ATF_TP_ADD_TC(tp, pollclosed_fifo1_immediate_readnone); 1694 ATF_TP_ADD_TC(tp, pollclosed_pipe_immediate_readnone); 1695 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_immediate_readnone); 1696 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_immediate_readnone); 1697 1698 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_process_write); 1699 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_process_write); 1700 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_process_write); 1701 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_process_write); 1702 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_process_write); 1703 1704 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_process_read); 1705 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_process_read); 1706 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_process_read); 1707 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_process_read); 1708 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_process_read); 1709 1710 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_thread_write); 1711 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_thread_write); 1712 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_thread_write); 1713 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_thread_write); 1714 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_thread_write); 1715 1716 ATF_TP_ADD_TC(tp, pollclosed_fifo0_delayed_thread_read); 1717 ATF_TP_ADD_TC(tp, pollclosed_fifo1_delayed_thread_read); 1718 ATF_TP_ADD_TC(tp, pollclosed_pipe_delayed_thread_read); 1719 ATF_TP_ADD_TC(tp, pollclosed_socketpair0_delayed_thread_read); 1720 ATF_TP_ADD_TC(tp, pollclosed_socketpair1_delayed_thread_read); 1721 1722 return atf_no_error(); 1723 } 1724
Indexes created Wed Sep 24 22:09:59 GMT 2025