t_futex_ops.c revision 1.5.8.2
1 /* $NetBSD: t_futex_ops.c,v 1.5.8.2 2021/08/07 01:46:54 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 2019, 2020 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __COPYRIGHT("@(#) Copyright (c) 2019, 2020\ 31 The NetBSD Foundation, inc. All rights reserved."); 32 __RCSID("$NetBSD: t_futex_ops.c,v 1.5.8.2 2021/08/07 01:46:54 thorpej Exp $"); 33 34 #include <sys/fcntl.h> 35 #include <sys/mman.h> 36 #include <sys/wait.h> 37 #include <atomic.h> 38 #include <errno.h> 39 #include <lwp.h> 40 #include <stdlib.h> 41 #include <stdio.h> 42 #include <signal.h> 43 #include <time.h> 44 #include <limits.h> 45 #include <sched.h> 46 #include <unistd.h> 47 48 #include <atf-c.h> 49 50 #include <libc/include/futex_private.h> 51 52 #define LOAD(x) (*(volatile int *)(x)) 53 #define STORE(x, y) *(volatile int *)(x) = (y) 54 55 #if 0 56 #define DPRINTF(x) printf x 57 #else 58 #define DPRINTF(x) __nothing 59 #endif 60 61 #define STACK_SIZE 65536 62 63 static volatile int futex_word; 64 static volatile int futex_word1; 65 66 static volatile unsigned int nlwps_running; 67 68 struct lwp_data { 69 ucontext_t context; 70 void (*func)(void *); 71 void *stack_base; 72 lwpid_t lwpid; 73 pid_t child; 74 lwpid_t threadid; 75 int wait_op; 76 int op_flags; 77 int bitset; 78 volatile int *futex_ptr; 79 volatile int *error_ptr; 80 int block_val; 81 82 void (*exit_func)(void); 83 84 int futex_error; 85 }; 86 87 #define WAITER_LWP0 0 88 #define WAITER_LWP1 1 89 #define WAITER_LWP2 2 90 #define WAITER_LWP3 3 91 #define WAITER_LWP4 4 92 #define WAITER_LWP5 5 93 #define NLWPS 6 94 95 struct lwp_data lwp_data[NLWPS]; 96 97 static const char *bs_path = "t_futex_ops_backing_store"; 98 static int bs_fd = -1; 99 static int *bs_addr = MAP_FAILED; 100 static void *bs_source_buffer = NULL; 101 static void *bs_verify_buffer = NULL; 102 static long bs_pagesize; 103 104 static void 105 create_lwp_waiter(struct lwp_data *d) 106 { 107 ATF_REQUIRE(_lwp_create(&d->context, 0, &d->lwpid) == 0); 108 } 109 110 static void 111 exit_lwp_waiter(void) 112 { 113 _lwp_exit(); 114 } 115 116 static void 117 reap_lwp_waiter(struct lwp_data *d) 118 { 119 ATF_REQUIRE(_lwp_wait(d->lwpid, NULL) == 0); 120 } 121 122 static void 123 create_proc_waiter(struct lwp_data *d) 124 { 125 pid_t pid; 126 127 ATF_REQUIRE((pid = fork()) != -1); 128 if (pid == 0) { 129 (*d->func)(d); 130 _exit(666); /* backstop */ 131 } else 132 d->child = pid; 133 } 134 135 static void 136 exit_proc_waiter(void) 137 { 138 _exit(0); 139 } 140 141 static void 142 reap_proc_waiter(struct lwp_data *d) 143 { 144 int status; 145 146 ATF_REQUIRE(waitpid(d->child, &status, 0) == d->child); 147 ATF_REQUIRE(WIFEXITED(status)); 148 ATF_REQUIRE(WEXITSTATUS(status) == 0); 149 } 150 151 static void 152 setup_lwp_context(struct lwp_data *d, void (*func)(void *)) 153 { 154 155 memset(d, 0, sizeof(*d)); 156 d->stack_base = mmap(NULL, STACK_SIZE, PROT_READ | PROT_WRITE, 157 MAP_ANON | MAP_STACK | MAP_PRIVATE, -1, 0); 158 ATF_REQUIRE(d->stack_base != MAP_FAILED); 159 _lwp_makecontext(&d->context, func, d, NULL, d->stack_base, STACK_SIZE); 160 d->threadid = 0; 161 d->func = func; 162 } 163 164 static void 165 simple_test_waiter_lwp(void *arg) 166 { 167 struct lwp_data *d = arg; 168 169 d->threadid = _lwp_self(); 170 171 membar_producer(); 172 atomic_inc_uint(&nlwps_running); 173 membar_sync(); 174 175 if (__futex(d->futex_ptr, d->wait_op | d->op_flags, 176 d->block_val, NULL, NULL, 0, d->bitset) == -1) { 177 d->futex_error = errno; 178 membar_sync(); 179 atomic_dec_uint(&nlwps_running); 180 _lwp_exit(); 181 } else { 182 d->futex_error = 0; 183 } 184 185 membar_sync(); 186 atomic_dec_uint(&nlwps_running); 187 188 _lwp_exit(); 189 } 190 191 static bool 192 verify_zero_bs(void) 193 { 194 195 if (bs_verify_buffer == NULL) { 196 bs_verify_buffer = malloc(bs_pagesize); 197 ATF_REQUIRE(bs_verify_buffer != NULL); 198 } 199 200 ATF_REQUIRE(pread(bs_fd, bs_verify_buffer, 201 bs_pagesize, 0) == bs_pagesize); 202 203 return (memcmp(bs_verify_buffer, bs_source_buffer, bs_pagesize) == 0); 204 } 205 206 static void 207 create_bs(int map_flags) 208 { 209 210 bs_pagesize = sysconf(_SC_PAGESIZE); 211 ATF_REQUIRE(bs_pagesize > 0); 212 213 if ((map_flags & (MAP_FILE | MAP_ANON)) == MAP_FILE) { 214 bs_source_buffer = calloc(1, bs_pagesize); 215 ATF_REQUIRE(bs_source_buffer != NULL); 216 217 bs_fd = open(bs_path, O_RDWR | O_CREAT | O_EXCL, 0644); 218 ATF_REQUIRE(bs_fd != -1); 219 220 ATF_REQUIRE(pwrite(bs_fd, bs_source_buffer, 221 bs_pagesize, 0) == bs_pagesize); 222 ATF_REQUIRE(verify_zero_bs()); 223 } 224 225 bs_addr = mmap(NULL, bs_pagesize, PROT_READ | PROT_WRITE, 226 map_flags | MAP_HASSEMAPHORE, bs_fd, 0); 227 ATF_REQUIRE(bs_addr != MAP_FAILED); 228 } 229 230 static void 231 cleanup_bs(void) 232 { 233 234 if (bs_fd != -1) { 235 (void) close(bs_fd); 236 bs_fd = -1; 237 (void) unlink(bs_path); 238 } 239 if (bs_source_buffer != NULL) { 240 free(bs_source_buffer); 241 bs_source_buffer = NULL; 242 } 243 if (bs_verify_buffer != NULL) { 244 free(bs_verify_buffer); 245 bs_verify_buffer = NULL; 246 } 247 if (bs_addr != MAP_FAILED) { 248 munmap(bs_addr, bs_pagesize); 249 bs_addr = MAP_FAILED; 250 } 251 } 252 253 static void 254 do_cleanup(void) 255 { 256 int i; 257 258 for (i = 0; i < NLWPS; i++) { 259 struct lwp_data *d = &lwp_data[i]; 260 if (d->stack_base != NULL && d->stack_base != MAP_FAILED) { 261 (void) munmap(d->stack_base, STACK_SIZE); 262 } 263 } 264 memset(lwp_data, 0, sizeof(lwp_data)); 265 STORE(&futex_word, 0); 266 STORE(&futex_word1, 0); 267 nlwps_running = 0; 268 269 cleanup_bs(); 270 } 271 272 /*****************************************************************************/ 273 274 static void 275 wait_wake_test_waiter_lwp(void *arg) 276 { 277 struct lwp_data *d = arg; 278 279 d->threadid = _lwp_self(); 280 281 STORE(d->futex_ptr, 1); 282 membar_sync(); 283 284 /* This will block because *futex_ptr == 1. */ 285 if (__futex(d->futex_ptr, FUTEX_WAIT | d->op_flags, 286 1, NULL, NULL, 0, 0) == -1) { 287 STORE(d->error_ptr, errno); 288 (*d->exit_func)(); 289 } else { 290 STORE(d->error_ptr, 0); 291 } 292 293 do { 294 membar_sync(); 295 sleep(1); 296 } while (LOAD(d->futex_ptr) != 0); 297 298 STORE(d->futex_ptr, 2); 299 membar_sync(); 300 301 do { 302 membar_sync(); 303 sleep(1); 304 } while (LOAD(d->futex_ptr) != 3); 305 306 /* This will not block because futex_word != 666. */ 307 if (__futex(d->futex_ptr, FUTEX_WAIT | d->op_flags, 308 666, NULL, NULL, 0, 0) == -1) { 309 /* This SHOULD be EAGAIN. */ 310 STORE(d->error_ptr, errno); 311 } 312 313 STORE(d->futex_ptr, 4); 314 membar_sync(); 315 316 (*d->exit_func)(); 317 } 318 319 static void 320 do_futex_wait_wake_test(volatile int *futex_ptr, volatile int *error_ptr, 321 void (*create_func)(struct lwp_data *), 322 void (*exit_func)(void), 323 void (*reap_func)(struct lwp_data *), 324 int flags) 325 { 326 struct lwp_data *wlwp = &lwp_data[WAITER_LWP0]; 327 int tries; 328 329 if (error_ptr == NULL) 330 error_ptr = &wlwp->futex_error; 331 332 if (create_func == NULL) 333 create_func = create_lwp_waiter; 334 if (exit_func == NULL) 335 exit_func = exit_lwp_waiter; 336 if (reap_func == NULL) 337 reap_func = reap_lwp_waiter; 338 339 setup_lwp_context(wlwp, wait_wake_test_waiter_lwp); 340 341 DPRINTF(("futex_basic_wait_wake: testing with flags 0x%x\n", flags)); 342 wlwp->op_flags = flags; 343 wlwp->error_ptr = error_ptr; 344 STORE(error_ptr, -1); 345 wlwp->futex_ptr = futex_ptr; 346 STORE(futex_ptr, 0); 347 wlwp->exit_func = exit_func; 348 membar_sync(); 349 350 DPRINTF(("futex_basic_wait_wake: creating watier LWP\n")); 351 (*create_func)(wlwp); 352 353 DPRINTF(("futex_basic_wait_wake: waiting for LWP %d to enter futex\n", 354 wlwp->lwpid)); 355 for (tries = 0; tries < 5; tries++) { 356 membar_sync(); 357 if (LOAD(futex_ptr) == 1) 358 break; 359 sleep(1); 360 } 361 membar_sync(); 362 ATF_REQUIRE(LOAD(futex_ptr) == 1); 363 364 /* 365 * If the LWP is blocked in the futex, it will not have yet 366 * modified *error_ptr. 367 */ 368 DPRINTF(("futex_basic_wait_wake: checking for successful wait (%d)\n", 369 LOAD(error_ptr))); 370 for (tries = 0; tries < 5; tries++) { 371 membar_sync(); 372 if (LOAD(error_ptr) == -1) 373 break; 374 sleep(1); 375 } 376 membar_sync(); 377 ATF_REQUIRE(LOAD(error_ptr) == -1); 378 379 /* Make sure invalid #wakes in rejected. */ 380 ATF_REQUIRE_ERRNO(EINVAL, 381 __futex(futex_ptr, FUTEX_WAKE | flags, 382 -1, NULL, NULL, 0, 0) == -1); 383 384 DPRINTF(("futex_basic_wait_wake: waking 1 waiter\n")); 385 ATF_REQUIRE(__futex(futex_ptr, FUTEX_WAKE | flags, 386 1, NULL, NULL, 0, 0) == 1); 387 388 DPRINTF(("futex_basic_wait_wake: checking for successful wake (%d)\n", 389 LOAD(error_ptr))); 390 for (tries = 0; tries < 5; tries++) { 391 membar_sync(); 392 if (LOAD(error_ptr) == 0) 393 break; 394 sleep(1); 395 } 396 membar_sync(); 397 ATF_REQUIRE(LOAD(error_ptr) == 0); 398 399 STORE(futex_ptr, 0); 400 membar_sync(); 401 402 DPRINTF(("futex_basic_wait_wake: waiting for LWP to advance (2)\n")); 403 for (tries = 0; tries < 5; tries++) { 404 membar_sync(); 405 if (LOAD(futex_ptr) == 2) 406 break; 407 sleep(1); 408 } 409 membar_sync(); 410 ATF_REQUIRE(LOAD(futex_ptr) == 2); 411 412 STORE(futex_ptr, 3); 413 membar_sync(); 414 415 DPRINTF(("futex_basic_wait_wake: waiting for LWP to advance (4)\n")); 416 for (tries = 0; tries < 5; tries++) { 417 membar_sync(); 418 if (LOAD(futex_ptr) == 4) 419 break; 420 sleep(1); 421 } 422 membar_sync(); 423 ATF_REQUIRE(LOAD(futex_ptr) == 4); 424 425 DPRINTF(("futex_basic_wait_wake: checking for expected EGAIN\n")); 426 ATF_REQUIRE(LOAD(error_ptr) == EAGAIN); 427 428 DPRINTF(("futex_basic_wait_wake: reaping LWP %d\n", wlwp->lwpid)); 429 (*reap_func)(wlwp); 430 } 431 432 ATF_TC_WITH_CLEANUP(futex_basic_wait_wake_private); 433 ATF_TC_HEAD(futex_basic_wait_wake_private, tc) 434 { 435 atf_tc_set_md_var(tc, "descr", 436 "tests basic futex WAIT + WAKE operations (PRIVATE)"); 437 } 438 ATF_TC_BODY(futex_basic_wait_wake_private, tc) 439 { 440 do_futex_wait_wake_test(&futex_word, NULL, 441 NULL, NULL, NULL, 442 FUTEX_PRIVATE_FLAG); 443 } 444 ATF_TC_CLEANUP(futex_basic_wait_wake_private, tc) 445 { 446 do_cleanup(); 447 } 448 449 ATF_TC_WITH_CLEANUP(futex_basic_wait_wake_shared); 450 ATF_TC_HEAD(futex_basic_wait_wake_shared, tc) 451 { 452 atf_tc_set_md_var(tc, "descr", 453 "tests basic futex WAIT + WAKE operations (SHARED)"); 454 } 455 ATF_TC_BODY(futex_basic_wait_wake_shared, tc) 456 { 457 do_futex_wait_wake_test(&futex_word, NULL, 458 NULL, NULL, NULL, 459 0); 460 } 461 ATF_TC_CLEANUP(futex_basic_wait_wake_shared, tc) 462 { 463 do_cleanup(); 464 } 465 466 ATF_TC_WITH_CLEANUP(futex_wait_wake_anon_bs_private); 467 ATF_TC_HEAD(futex_wait_wake_anon_bs_private, tc) 468 { 469 atf_tc_set_md_var(tc, "descr", 470 "tests futex WAIT + WAKE operations (MAP_ANON + PRIVATE)"); 471 } 472 ATF_TC_BODY(futex_wait_wake_anon_bs_private, tc) 473 { 474 create_bs(MAP_ANON | MAP_PRIVATE); 475 do_futex_wait_wake_test(&bs_addr[0], NULL, 476 NULL, NULL, NULL, 477 FUTEX_PRIVATE_FLAG); 478 } 479 ATF_TC_CLEANUP(futex_wait_wake_anon_bs_private, tc) 480 { 481 do_cleanup(); 482 } 483 484 ATF_TC_WITH_CLEANUP(futex_wait_wake_anon_bs_shared); 485 ATF_TC_HEAD(futex_wait_wake_anon_bs_shared, tc) 486 { 487 atf_tc_set_md_var(tc, "descr", 488 "tests futex WAIT + WAKE operations (MAP_ANON + SHARED)"); 489 } 490 ATF_TC_BODY(futex_wait_wake_anon_bs_shared, tc) 491 { 492 create_bs(MAP_ANON | MAP_PRIVATE); 493 do_futex_wait_wake_test(&bs_addr[0], NULL, 494 NULL, NULL, NULL, 495 0); 496 } 497 ATF_TC_CLEANUP(futex_wait_wake_anon_bs_shared, tc) 498 { 499 do_cleanup(); 500 } 501 502 ATF_TC_WITH_CLEANUP(futex_wait_wake_file_bs_private); 503 ATF_TC_HEAD(futex_wait_wake_file_bs_private, tc) 504 { 505 atf_tc_set_md_var(tc, "descr", 506 "tests futex WAIT + WAKE operations (MAP_FILE + PRIVATE)"); 507 } 508 ATF_TC_BODY(futex_wait_wake_file_bs_private, tc) 509 { 510 /* 511 * This combination (non-COW mapped file + PRIVATE futex) 512 * doesn't really make sense, but we should make sure it 513 * works as expected. 514 */ 515 create_bs(MAP_FILE | MAP_SHARED); 516 do_futex_wait_wake_test(&bs_addr[0], NULL, 517 NULL, NULL, NULL, 518 FUTEX_PRIVATE_FLAG); 519 ATF_REQUIRE(! verify_zero_bs()); 520 } 521 ATF_TC_CLEANUP(futex_wait_wake_file_bs_private, tc) 522 { 523 do_cleanup(); 524 } 525 526 ATF_TC_WITH_CLEANUP(futex_wait_wake_file_bs_cow_private); 527 ATF_TC_HEAD(futex_wait_wake_file_bs_cow_private, tc) 528 { 529 atf_tc_set_md_var(tc, "descr", 530 "tests futex WAIT + WAKE operations (MAP_FILE COW + PRIVATE)"); 531 } 532 ATF_TC_BODY(futex_wait_wake_file_bs_cow_private, tc) 533 { 534 create_bs(MAP_FILE | MAP_PRIVATE); 535 do_futex_wait_wake_test(&bs_addr[0], NULL, 536 NULL, NULL, NULL, 537 FUTEX_PRIVATE_FLAG); 538 ATF_REQUIRE(verify_zero_bs()); 539 } 540 ATF_TC_CLEANUP(futex_wait_wake_file_bs_cow_private, tc) 541 { 542 do_cleanup(); 543 } 544 545 ATF_TC_WITH_CLEANUP(futex_wait_wake_file_bs_shared); 546 ATF_TC_HEAD(futex_wait_wake_file_bs_shared, tc) 547 { 548 atf_tc_set_md_var(tc, "descr", 549 "tests futex WAIT + WAKE operations (MAP_FILE + SHARED)"); 550 } 551 ATF_TC_BODY(futex_wait_wake_file_bs_shared, tc) 552 { 553 create_bs(MAP_FILE | MAP_SHARED); 554 do_futex_wait_wake_test(&bs_addr[0], NULL, 555 NULL, NULL, NULL, 556 0); 557 ATF_REQUIRE(! verify_zero_bs()); 558 } 559 ATF_TC_CLEANUP(futex_wait_wake_file_bs_shared, tc) 560 { 561 do_cleanup(); 562 } 563 564 ATF_TC_WITH_CLEANUP(futex_wait_wake_file_bs_cow_shared); 565 ATF_TC_HEAD(futex_wait_wake_file_bs_cow_shared, tc) 566 { 567 atf_tc_set_md_var(tc, "descr", 568 "tests futex WAIT + WAKE operations (MAP_FILE COW + SHARED)"); 569 } 570 ATF_TC_BODY(futex_wait_wake_file_bs_cow_shared, tc) 571 { 572 /* 573 * This combination (COW mapped file + SHARED futex) 574 * doesn't really make sense, but we should make sure it 575 * works as expected. 576 */ 577 create_bs(MAP_FILE | MAP_PRIVATE); 578 do_futex_wait_wake_test(&bs_addr[0], NULL, 579 NULL, NULL, NULL, 580 0); 581 ATF_REQUIRE(verify_zero_bs()); 582 } 583 ATF_TC_CLEANUP(futex_wait_wake_file_bs_cow_shared, tc) 584 { 585 do_cleanup(); 586 } 587 588 ATF_TC_WITH_CLEANUP(futex_wait_wake_anon_bs_shared_proc); 589 ATF_TC_HEAD(futex_wait_wake_anon_bs_shared_proc, tc) 590 { 591 atf_tc_set_md_var(tc, "descr", 592 "tests multiproc futex WAIT + WAKE operations (MAP_ANON + SHARED)"); 593 } 594 ATF_TC_BODY(futex_wait_wake_anon_bs_shared_proc, tc) 595 { 596 create_bs(MAP_ANON | MAP_SHARED); 597 do_futex_wait_wake_test(&bs_addr[0], &bs_addr[1], 598 create_proc_waiter, 599 exit_proc_waiter, 600 reap_proc_waiter, 601 0); 602 } 603 ATF_TC_CLEANUP(futex_wait_wake_anon_bs_shared_proc, tc) 604 { 605 do_cleanup(); 606 } 607 608 ATF_TC_WITH_CLEANUP(futex_wait_wake_file_bs_shared_proc); 609 ATF_TC_HEAD(futex_wait_wake_file_bs_shared_proc, tc) 610 { 611 atf_tc_set_md_var(tc, "descr", 612 "tests multiproc futex WAIT + WAKE operations (MAP_ANON + SHARED)"); 613 } 614 ATF_TC_BODY(futex_wait_wake_file_bs_shared_proc, tc) 615 { 616 create_bs(MAP_FILE | MAP_SHARED); 617 do_futex_wait_wake_test(&bs_addr[0], &bs_addr[1], 618 create_proc_waiter, 619 exit_proc_waiter, 620 reap_proc_waiter, 621 0); 622 } 623 ATF_TC_CLEANUP(futex_wait_wake_file_bs_shared_proc, tc) 624 { 625 do_cleanup(); 626 } 627 628 /*****************************************************************************/ 629 630 ATF_TC(futex_wait_pointless_bitset); 631 ATF_TC_HEAD(futex_wait_pointless_bitset, tc) 632 { 633 atf_tc_set_md_var(tc, "descr", 634 "tests basic futex WAIT + WAKE operations (SHARED)"); 635 } 636 ATF_TC_BODY(futex_wait_pointless_bitset, tc) 637 { 638 639 futex_word = 1; 640 ATF_REQUIRE_ERRNO(EINVAL, 641 __futex(&futex_word, FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG, 642 1, NULL, NULL, 0, 0) == -1); 643 } 644 645 static void 646 do_futex_wait_wake_bitset_test(int flags) 647 { 648 struct lwp_data *wlwp0 = &lwp_data[WAITER_LWP0]; 649 struct lwp_data *wlwp1 = &lwp_data[WAITER_LWP1]; 650 int i, tries; 651 652 for (i = WAITER_LWP0; i <= WAITER_LWP1; i++) { 653 setup_lwp_context(&lwp_data[i], simple_test_waiter_lwp); 654 lwp_data[i].op_flags = flags; 655 lwp_data[i].futex_error = -1; 656 lwp_data[i].bitset = __BIT(i); 657 lwp_data[i].wait_op = FUTEX_WAIT_BITSET; 658 lwp_data[i].futex_ptr = &futex_word; 659 lwp_data[i].block_val = 1; 660 } 661 662 STORE(&futex_word, 1); 663 membar_sync(); 664 665 ATF_REQUIRE(_lwp_create(&wlwp0->context, 0, &wlwp0->lwpid) == 0); 666 ATF_REQUIRE(_lwp_create(&wlwp1->context, 0, &wlwp1->lwpid) == 0); 667 668 for (tries = 0; tries < 5; tries++) { 669 membar_sync(); 670 if (nlwps_running == 2) 671 break; 672 sleep(1); 673 } 674 membar_sync(); 675 ATF_REQUIRE_EQ_MSG(nlwps_running, 2, "waiters failed to start"); 676 677 /* Ensure they're blocked. */ 678 ATF_REQUIRE(wlwp0->futex_error == -1); 679 ATF_REQUIRE(wlwp1->futex_error == -1); 680 681 /* Make sure invalid #wakes in rejected. */ 682 ATF_REQUIRE_ERRNO(EINVAL, 683 __futex(&futex_word, FUTEX_WAKE_BITSET | flags, 684 -1, NULL, NULL, 0, 0) == -1); 685 686 /* This should result in no wakeups because no bits are set. */ 687 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_BITSET | flags, 688 INT_MAX, NULL, NULL, 0, 0) == 0); 689 690 /* This should result in no wakeups because the wrongs bits are set. */ 691 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_BITSET | flags, 692 INT_MAX, NULL, NULL, 0, 693 ~(wlwp0->bitset | wlwp1->bitset)) == 0); 694 695 /* Trust, but verify. */ 696 sleep(1); 697 for (tries = 0; tries < 5; tries++) { 698 membar_sync(); 699 if (nlwps_running == 2) 700 break; 701 sleep(1); 702 } 703 membar_sync(); 704 ATF_REQUIRE_EQ_MSG(nlwps_running, 2, "waiters exited unexpectedly"); 705 706 /* Wake up the first LWP. */ 707 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_BITSET | flags, 708 INT_MAX, NULL, NULL, 0, 709 wlwp0->bitset) == 1); 710 sleep(1); 711 for (tries = 0; tries < 5; tries++) { 712 membar_sync(); 713 if (nlwps_running == 1) 714 break; 715 sleep(1); 716 } 717 membar_sync(); 718 ATF_REQUIRE(nlwps_running == 1); 719 ATF_REQUIRE(wlwp0->futex_error == 0); 720 ATF_REQUIRE(_lwp_wait(wlwp0->lwpid, NULL) == 0); 721 722 /* Wake up the second LWP. */ 723 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_BITSET | flags, 724 INT_MAX, NULL, NULL, 0, 725 wlwp1->bitset) == 1); 726 sleep(1); 727 for (tries = 0; tries < 5; tries++) { 728 membar_sync(); 729 if (nlwps_running == 0) 730 break; 731 sleep(1); 732 } 733 membar_sync(); 734 ATF_REQUIRE(nlwps_running == 0); 735 ATF_REQUIRE(wlwp1->futex_error == 0); 736 ATF_REQUIRE(_lwp_wait(wlwp1->lwpid, NULL) == 0); 737 } 738 739 ATF_TC_WITH_CLEANUP(futex_wait_wake_bitset); 740 ATF_TC_HEAD(futex_wait_wake_bitset, tc) 741 { 742 atf_tc_set_md_var(tc, "descr", 743 "tests futex WAIT_BITSET + WAKE_BITSET operations"); 744 } 745 ATF_TC_BODY(futex_wait_wake_bitset, tc) 746 { 747 do_futex_wait_wake_bitset_test(FUTEX_PRIVATE_FLAG); 748 } 749 ATF_TC_CLEANUP(futex_wait_wake_bitset, tc) 750 { 751 do_cleanup(); 752 } 753 754 /*****************************************************************************/ 755 756 static void 757 do_futex_requeue_test(int flags, int op) 758 { 759 struct lwp_data *wlwp0 = &lwp_data[WAITER_LWP0]; 760 struct lwp_data *wlwp1 = &lwp_data[WAITER_LWP1]; 761 struct lwp_data *wlwp2 = &lwp_data[WAITER_LWP2]; 762 struct lwp_data *wlwp3 = &lwp_data[WAITER_LWP3]; 763 const int good_val3 = (op == FUTEX_CMP_REQUEUE) ? 1 : 0; 764 const int bad_val3 = (op == FUTEX_CMP_REQUEUE) ? 666 : 0; 765 int i, tries; 766 767 for (i = WAITER_LWP0; i <= WAITER_LWP3; i++) { 768 setup_lwp_context(&lwp_data[i], simple_test_waiter_lwp); 769 lwp_data[i].op_flags = flags; 770 lwp_data[i].futex_error = -1; 771 lwp_data[i].futex_ptr = &futex_word; 772 lwp_data[i].block_val = 1; 773 lwp_data[i].bitset = 0; 774 lwp_data[i].wait_op = FUTEX_WAIT; 775 } 776 777 STORE(&futex_word, 1); 778 STORE(&futex_word1, 1); 779 membar_sync(); 780 781 ATF_REQUIRE(_lwp_create(&wlwp0->context, 0, &wlwp0->lwpid) == 0); 782 ATF_REQUIRE(_lwp_create(&wlwp1->context, 0, &wlwp1->lwpid) == 0); 783 ATF_REQUIRE(_lwp_create(&wlwp2->context, 0, &wlwp2->lwpid) == 0); 784 ATF_REQUIRE(_lwp_create(&wlwp3->context, 0, &wlwp3->lwpid) == 0); 785 786 for (tries = 0; tries < 5; tries++) { 787 membar_sync(); 788 if (nlwps_running == 4) 789 break; 790 sleep(1); 791 } 792 membar_sync(); 793 ATF_REQUIRE_EQ_MSG(nlwps_running, 4, "waiters failed to start"); 794 795 /* Ensure they're blocked. */ 796 ATF_REQUIRE(wlwp0->futex_error == -1); 797 ATF_REQUIRE(wlwp1->futex_error == -1); 798 ATF_REQUIRE(wlwp2->futex_error == -1); 799 ATF_REQUIRE(wlwp3->futex_error == -1); 800 801 /* Make sure invalid #wakes and #requeues are rejected. */ 802 ATF_REQUIRE_ERRNO(EINVAL, 803 __futex(&futex_word, op | flags, 804 -1, NULL, &futex_word1, INT_MAX, bad_val3) == -1); 805 806 ATF_REQUIRE_ERRNO(EINVAL, 807 __futex(&futex_word, op | flags, 808 0, NULL, &futex_word1, -1, bad_val3) == -1); 809 810 /* 811 * FUTEX 0: 4 LWPs 812 * FUTEX 1: 0 LWPs 813 */ 814 815 if (op == FUTEX_CMP_REQUEUE) { 816 /* This should fail because the futex_word value is 1. */ 817 ATF_REQUIRE_ERRNO(EAGAIN, 818 __futex(&futex_word, op | flags, 819 0, NULL, &futex_word1, INT_MAX, bad_val3) == -1); 820 } 821 822 /* 823 * FUTEX 0: 4 LWPs 824 * FUTEX 1: 0 LWPs 825 */ 826 827 /* 828 * Move all waiters from 0 to 1. 829 * 830 * N.B. different return value semantics for FUTEX_REQUEUE 831 * vs. FUTEX_CMP_REQUEUE. 832 */ 833 if (op == FUTEX_CMP_REQUEUE) { 834 ATF_REQUIRE(__futex(&futex_word, op | flags, 835 0, NULL, &futex_word1, INT_MAX, 836 good_val3) == 4); 837 } else { 838 ATF_REQUIRE(__futex(&futex_word, op | flags, 839 0, NULL, &futex_word1, INT_MAX, 840 good_val3) == 0); 841 } 842 843 /* 844 * FUTEX 0: 0 LWPs 845 * FUTEX 1: 4 LWPs 846 */ 847 848 if (op == FUTEX_CMP_REQUEUE) { 849 /* This should fail because the futex_word1 value is 1. */ 850 ATF_REQUIRE_ERRNO(EAGAIN, 851 __futex(&futex_word1, op | flags, 852 1, NULL, &futex_word, 1, bad_val3) == -1); 853 } 854 855 /* 856 * FUTEX 0: 0 LWPs 857 * FUTEX 1: 4 LWPs 858 */ 859 860 /* Wake one waiter on 1, move one waiter to 0. */ 861 ATF_REQUIRE(__futex(&futex_word1, op | flags, 862 1, NULL, &futex_word, 1, good_val3) == 1); 863 864 /* 865 * FUTEX 0: 1 LWP 866 * FUTEX 1: 2 LWPs 867 */ 868 869 /* Wake all waiters on 0 (should be 1). */ 870 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE | flags, 871 INT_MAX, NULL, NULL, 0, 0) == 1); 872 873 /* Wake all waiters on 1 (should be 2). */ 874 ATF_REQUIRE(__futex(&futex_word1, FUTEX_WAKE | flags, 875 INT_MAX, NULL, NULL, 0, 0) == 2); 876 877 /* Trust, but verify. */ 878 sleep(1); 879 for (tries = 0; tries < 5; tries++) { 880 membar_sync(); 881 if (nlwps_running == 0) 882 break; 883 sleep(1); 884 } 885 membar_sync(); 886 ATF_REQUIRE_EQ_MSG(nlwps_running, 0, "waiters failed to exit"); 887 888 ATF_REQUIRE(_lwp_wait(wlwp0->lwpid, NULL) == 0); 889 ATF_REQUIRE(_lwp_wait(wlwp1->lwpid, NULL) == 0); 890 ATF_REQUIRE(_lwp_wait(wlwp2->lwpid, NULL) == 0); 891 ATF_REQUIRE(_lwp_wait(wlwp3->lwpid, NULL) == 0); 892 } 893 894 ATF_TC_WITH_CLEANUP(futex_requeue); 895 ATF_TC_HEAD(futex_requeue, tc) 896 { 897 atf_tc_set_md_var(tc, "descr", 898 "tests futex REQUEUE operations"); 899 } 900 ATF_TC_BODY(futex_requeue, tc) 901 { 902 do_futex_requeue_test(FUTEX_PRIVATE_FLAG, FUTEX_REQUEUE); 903 } 904 ATF_TC_CLEANUP(futex_requeue, tc) 905 { 906 do_cleanup(); 907 } 908 909 ATF_TC_WITH_CLEANUP(futex_cmp_requeue); 910 ATF_TC_HEAD(futex_cmp_requeue, tc) 911 { 912 atf_tc_set_md_var(tc, "descr", 913 "tests futex CMP_REQUEUE operations"); 914 } 915 ATF_TC_BODY(futex_cmp_requeue, tc) 916 { 917 do_futex_requeue_test(FUTEX_PRIVATE_FLAG, FUTEX_CMP_REQUEUE); 918 } 919 ATF_TC_CLEANUP(futex_cmp_requeue, tc) 920 { 921 do_cleanup(); 922 } 923 924 /*****************************************************************************/ 925 926 static void 927 do_futex_wake_op_op_test(int flags) 928 { 929 int op; 930 931 futex_word = 0; 932 futex_word1 = 0; 933 934 /* 935 * The op= operations should work even if there are no waiters. 936 */ 937 938 /* 939 * Because these operations use both futex addresses, exercise 940 * rejecting unaligned futex addresses here. 941 */ 942 op = FUTEX_OP(FUTEX_OP_SET, 1, FUTEX_OP_CMP_EQ, 0); 943 ATF_REQUIRE_ERRNO(EINVAL, 944 __futex((int *)1, FUTEX_WAKE_OP | flags, 945 0, NULL, &futex_word1, 0, op) == -1); 946 ATF_REQUIRE(futex_word1 == 0); 947 948 ATF_REQUIRE_ERRNO(EINVAL, 949 __futex(&futex_word, FUTEX_WAKE_OP | flags, 950 0, NULL, (int *)1, 0, op) == -1); 951 ATF_REQUIRE(futex_word == 0); 952 953 /* Check unmapped uaddr2 handling, too. */ 954 ATF_REQUIRE_ERRNO(EFAULT, 955 __futex(&futex_word, FUTEX_WAKE_OP | flags, 956 0, NULL, NULL, 0, op) == -1); 957 ATF_REQUIRE(futex_word == 0); 958 959 op = FUTEX_OP(FUTEX_OP_SET, 1, FUTEX_OP_CMP_EQ, 0); 960 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 961 0, NULL, &futex_word1, 0, op) == 0); 962 ATF_REQUIRE(futex_word1 == 1); 963 964 op = FUTEX_OP(FUTEX_OP_ADD, 1, FUTEX_OP_CMP_EQ, 0); 965 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 966 0, NULL, &futex_word1, 0, op) == 0); 967 ATF_REQUIRE(futex_word1 == 2); 968 969 op = FUTEX_OP(FUTEX_OP_OR, 2, FUTEX_OP_CMP_EQ, 0); 970 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 971 0, NULL, &futex_word1, 0, op) == 0); 972 ATF_REQUIRE(futex_word1 == 2); 973 974 /* This should fail because of invalid shift value 32. */ 975 op = FUTEX_OP(FUTEX_OP_OR | FUTEX_OP_OPARG_SHIFT, 32, 976 FUTEX_OP_CMP_EQ, 0); 977 ATF_REQUIRE_ERRNO(EINVAL, 978 __futex(&futex_word, FUTEX_WAKE_OP | flags, 979 0, NULL, &futex_word1, 0, op) == -1); 980 ATF_REQUIRE(futex_word1 == 2); 981 982 op = FUTEX_OP(FUTEX_OP_OR | FUTEX_OP_OPARG_SHIFT, 31, 983 FUTEX_OP_CMP_EQ, 0); 984 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 985 0, NULL, &futex_word1, 0, op) == 0); 986 ATF_REQUIRE(futex_word1 == (int)0x80000002); 987 988 op = FUTEX_OP(FUTEX_OP_ANDN | FUTEX_OP_OPARG_SHIFT, 31, 989 FUTEX_OP_CMP_EQ, 0); 990 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 991 0, NULL, &futex_word1, 0, op) == 0); 992 ATF_REQUIRE(futex_word1 == 2); 993 994 op = FUTEX_OP(FUTEX_OP_XOR, 2, FUTEX_OP_CMP_EQ, 0); 995 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 996 0, NULL, &futex_word1, 0, op) == 0); 997 ATF_REQUIRE(futex_word1 == 0); 998 } 999 1000 ATF_TC_WITH_CLEANUP(futex_wake_op_op); 1001 ATF_TC_HEAD(futex_wake_op_op, tc) 1002 { 1003 atf_tc_set_md_var(tc, "descr", 1004 "tests futex WAKE_OP OP operations"); 1005 } 1006 ATF_TC_BODY(futex_wake_op_op, tc) 1007 { 1008 do_futex_wake_op_op_test(FUTEX_PRIVATE_FLAG); 1009 } 1010 ATF_TC_CLEANUP(futex_wake_op_op, tc) 1011 { 1012 do_cleanup(); 1013 } 1014 1015 static void 1016 create_wake_op_test_lwps(int flags) 1017 { 1018 int i; 1019 1020 futex_word1 = 0; 1021 membar_sync(); 1022 1023 for (i = WAITER_LWP0; i <= WAITER_LWP5; i++) { 1024 setup_lwp_context(&lwp_data[i], simple_test_waiter_lwp); 1025 lwp_data[i].op_flags = flags; 1026 lwp_data[i].futex_error = -1; 1027 lwp_data[i].futex_ptr = &futex_word1; 1028 lwp_data[i].block_val = 0; 1029 lwp_data[i].bitset = 0; 1030 lwp_data[i].wait_op = FUTEX_WAIT; 1031 ATF_REQUIRE(_lwp_create(&lwp_data[i].context, 0, 1032 &lwp_data[i].lwpid) == 0); 1033 } 1034 1035 for (i = 0; i < 5; i++) { 1036 membar_sync(); 1037 if (nlwps_running == 6) 1038 break; 1039 sleep(1); 1040 } 1041 membar_sync(); 1042 ATF_REQUIRE_EQ_MSG(nlwps_running, 6, "waiters failed to start"); 1043 1044 /* Ensure they're blocked. */ 1045 for (i = WAITER_LWP0; i <= WAITER_LWP5; i++) { 1046 ATF_REQUIRE(lwp_data[i].futex_error == -1); 1047 } 1048 } 1049 1050 static void 1051 reap_wake_op_test_lwps(void) 1052 { 1053 int i; 1054 1055 for (i = WAITER_LWP0; i <= WAITER_LWP5; i++) { 1056 ATF_REQUIRE(_lwp_wait(lwp_data[i].lwpid, NULL) == 0); 1057 } 1058 } 1059 1060 static void 1061 do_futex_wake_op_cmp_test(int flags) 1062 { 1063 int tries, op; 1064 1065 futex_word = 0; 1066 membar_sync(); 1067 1068 /* 1069 * Verify and negative and positive for each individual 1070 * compare. 1071 */ 1072 1073 create_wake_op_test_lwps(flags); 1074 1075 /* #LWPs = 6 */ 1076 op = FUTEX_OP(FUTEX_OP_SET, 0, FUTEX_OP_CMP_EQ, 1); 1077 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1078 0, NULL, &futex_word1, 1, op) == 0); 1079 ATF_REQUIRE(futex_word1 == 0); 1080 1081 op = FUTEX_OP(FUTEX_OP_SET, 1, FUTEX_OP_CMP_EQ, 0); 1082 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1083 0, NULL, &futex_word1, 1, op) == 1); 1084 ATF_REQUIRE(futex_word1 == 1); 1085 1086 /* #LWPs = 5 */ 1087 op = FUTEX_OP(FUTEX_OP_SET, 1, FUTEX_OP_CMP_NE, 1); 1088 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1089 0, NULL, &futex_word1, 1, op) == 0); 1090 ATF_REQUIRE(futex_word1 == 1); 1091 1092 op = FUTEX_OP(FUTEX_OP_SET, 2, FUTEX_OP_CMP_NE, 2); 1093 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1094 0, NULL, &futex_word1, 1, op) == 1); 1095 ATF_REQUIRE(futex_word1 == 2); 1096 1097 /* #LWPs = 4 */ 1098 op = FUTEX_OP(FUTEX_OP_SET, 2, FUTEX_OP_CMP_LT, 2); 1099 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1100 0, NULL, &futex_word1, 1, op) == 0); 1101 ATF_REQUIRE(futex_word1 == 2); 1102 1103 op = FUTEX_OP(FUTEX_OP_SET, 2, FUTEX_OP_CMP_LT, 3); 1104 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1105 0, NULL, &futex_word1, 1, op) == 1); 1106 ATF_REQUIRE(futex_word1 == 2); 1107 1108 /* #LWPs = 3 */ 1109 op = FUTEX_OP(FUTEX_OP_SET, 1, FUTEX_OP_CMP_LE, 1); 1110 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1111 0, NULL, &futex_word1, 1, op) == 0); 1112 ATF_REQUIRE(futex_word1 == 1); 1113 1114 op = FUTEX_OP(FUTEX_OP_SET, 1, FUTEX_OP_CMP_LE, 1); 1115 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1116 0, NULL, &futex_word1, 1, op) == 1); 1117 ATF_REQUIRE(futex_word1 == 1); 1118 1119 /* #LWPs = 2 */ 1120 op = FUTEX_OP(FUTEX_OP_SET, 3, FUTEX_OP_CMP_GT, 3); 1121 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1122 0, NULL, &futex_word1, 1, op) == 0); 1123 ATF_REQUIRE(futex_word1 == 3); 1124 1125 op = FUTEX_OP(FUTEX_OP_SET, 2, FUTEX_OP_CMP_GT, 2); 1126 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1127 0, NULL, &futex_word1, 1, op) == 1); 1128 ATF_REQUIRE(futex_word1 == 2); 1129 1130 /* #LWPs = 1 */ 1131 op = FUTEX_OP(FUTEX_OP_SET, 3, FUTEX_OP_CMP_GE, 4); 1132 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1133 0, NULL, &futex_word1, 1, op) == 0); 1134 ATF_REQUIRE(futex_word1 == 3); 1135 1136 op = FUTEX_OP(FUTEX_OP_SET, 2, FUTEX_OP_CMP_GE, 3); 1137 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE_OP | flags, 1138 0, NULL, &futex_word1, 1, op) == 1); 1139 ATF_REQUIRE(futex_word1 == 2); 1140 1141 /* #LWPs = 0 */ 1142 1143 /* Trust, but verify. */ 1144 sleep(1); 1145 for (tries = 0; tries < 5; tries++) { 1146 membar_sync(); 1147 if (nlwps_running == 0) 1148 break; 1149 sleep(1); 1150 } 1151 membar_sync(); 1152 ATF_REQUIRE_EQ_MSG(nlwps_running, 0, "waiters failed to exit"); 1153 1154 reap_wake_op_test_lwps(); 1155 1156 /* 1157 * Verify wakes on uaddr work even if the uaddr2 comparison 1158 * fails. 1159 */ 1160 1161 create_wake_op_test_lwps(flags); 1162 1163 /* #LWPs = 6 */ 1164 ATF_REQUIRE(futex_word == 0); 1165 op = FUTEX_OP(FUTEX_OP_SET, 0, FUTEX_OP_CMP_EQ, 666); 1166 ATF_REQUIRE(__futex(&futex_word1, FUTEX_WAKE_OP | flags, 1167 INT_MAX, NULL, &futex_word, 0, op) == 6); 1168 ATF_REQUIRE(futex_word == 0); 1169 1170 /* #LWPs = 0 */ 1171 1172 /* Trust, but verify. */ 1173 sleep(1); 1174 for (tries = 0; tries < 5; tries++) { 1175 membar_sync(); 1176 if (nlwps_running == 0) 1177 break; 1178 sleep(1); 1179 } 1180 membar_sync(); 1181 ATF_REQUIRE_EQ_MSG(nlwps_running, 0, "waiters failed to exit"); 1182 1183 reap_wake_op_test_lwps(); 1184 } 1185 1186 ATF_TC_WITH_CLEANUP(futex_wake_op_cmp); 1187 ATF_TC_HEAD(futex_wake_op_cmp, tc) 1188 { 1189 atf_tc_set_md_var(tc, "descr", 1190 "tests futex WAKE_OP CMP operations"); 1191 } 1192 ATF_TC_BODY(futex_wake_op_cmp, tc) 1193 { 1194 do_futex_wake_op_cmp_test(FUTEX_PRIVATE_FLAG); 1195 } 1196 ATF_TC_CLEANUP(futex_wake_op_cmp, tc) 1197 { 1198 do_cleanup(); 1199 } 1200 1201 /*****************************************************************************/ 1202 1203 static void 1204 do_futex_wait_timeout(bool relative, clockid_t clock) 1205 { 1206 struct timespec ts; 1207 struct timespec deadline; 1208 int op = relative ? FUTEX_WAIT : FUTEX_WAIT_BITSET; 1209 1210 if (clock == CLOCK_REALTIME) 1211 op |= FUTEX_CLOCK_REALTIME; 1212 1213 ATF_REQUIRE(clock_gettime(clock, &deadline) == 0); 1214 deadline.tv_sec += 2; 1215 if (relative) { 1216 ts.tv_sec = 2; 1217 ts.tv_nsec = 0; 1218 } else { 1219 ts = deadline; 1220 } 1221 1222 futex_word = 1; 1223 ATF_REQUIRE_ERRNO(ETIMEDOUT, 1224 __futex(&futex_word, op | FUTEX_PRIVATE_FLAG, 1225 1, &ts, NULL, 0, FUTEX_BITSET_MATCH_ANY) == -1); 1226 1227 /* Can't reliably check CLOCK_REALTIME in the presence of NTP. */ 1228 if (clock != CLOCK_REALTIME) { 1229 ATF_REQUIRE(clock_gettime(clock, &ts) == 0); 1230 ATF_REQUIRE(ts.tv_sec >= deadline.tv_sec); 1231 ATF_REQUIRE(ts.tv_sec > deadline.tv_sec || 1232 ts.tv_nsec >= deadline.tv_nsec); 1233 } 1234 } 1235 1236 ATF_TC(futex_wait_timeout_relative); 1237 ATF_TC_HEAD(futex_wait_timeout_relative, tc) 1238 { 1239 atf_tc_set_md_var(tc, "descr", 1240 "tests futex WAIT with relative timeout"); 1241 } 1242 ATF_TC_BODY(futex_wait_timeout_relative, tc) 1243 { 1244 do_futex_wait_timeout(true, CLOCK_MONOTONIC); 1245 } 1246 1247 ATF_TC(futex_wait_timeout_relative_rt); 1248 ATF_TC_HEAD(futex_wait_timeout_relative_rt, tc) 1249 { 1250 atf_tc_set_md_var(tc, "descr", 1251 "tests futex WAIT with relative timeout (REALTIME)"); 1252 } 1253 ATF_TC_BODY(futex_wait_timeout_relative_rt, tc) 1254 { 1255 do_futex_wait_timeout(true, CLOCK_REALTIME); 1256 } 1257 1258 ATF_TC(futex_wait_timeout_deadline); 1259 ATF_TC_HEAD(futex_wait_timeout_deadline, tc) 1260 { 1261 atf_tc_set_md_var(tc, "descr", 1262 "tests futex WAIT with absolute deadline"); 1263 } 1264 ATF_TC_BODY(futex_wait_timeout_deadline, tc) 1265 { 1266 do_futex_wait_timeout(false, CLOCK_MONOTONIC); 1267 } 1268 1269 ATF_TC(futex_wait_timeout_deadline_rt); 1270 ATF_TC_HEAD(futex_wait_timeout_deadline_rt, tc) 1271 { 1272 atf_tc_set_md_var(tc, "descr", 1273 "tests futex WAIT with absolute deadline (REALTIME)"); 1274 } 1275 ATF_TC_BODY(futex_wait_timeout_deadline_rt, tc) 1276 { 1277 do_futex_wait_timeout(false, CLOCK_REALTIME); 1278 } 1279 1280 /*****************************************************************************/ 1281 1282 static void 1283 sig_noop(int sig __unused) 1284 { 1285 } 1286 1287 static void (*old_act)(int) = SIG_DFL; 1288 1289 static void 1290 do_futex_wait_evil_unmapped(int map_flags) 1291 { 1292 int i; 1293 1294 create_bs(map_flags); 1295 1296 old_act = signal(SIGUSR1, sig_noop); 1297 ATF_REQUIRE(old_act != SIG_ERR); 1298 1299 setup_lwp_context(&lwp_data[0], simple_test_waiter_lwp); 1300 lwp_data[0].op_flags = 0; 1301 lwp_data[0].futex_error = -1; 1302 lwp_data[0].futex_ptr = &bs_addr[0]; 1303 lwp_data[0].block_val = 0; 1304 lwp_data[0].bitset = 0; 1305 lwp_data[0].wait_op = FUTEX_WAIT; 1306 ATF_REQUIRE(_lwp_create(&lwp_data[0].context, 0, 1307 &lwp_data[0].lwpid) == 0); 1308 1309 for (i = 0; i < 5; i++) { 1310 membar_sync(); 1311 if (nlwps_running == 1) 1312 break; 1313 sleep(1); 1314 } 1315 membar_sync(); 1316 ATF_REQUIRE_EQ_MSG(nlwps_running, 1, "waiters failed to start"); 1317 1318 /* Ensure it's blocked. */ 1319 ATF_REQUIRE(lwp_data[0].futex_error == -1); 1320 1321 /* Rudely unmap the backing store. */ 1322 cleanup_bs(); 1323 1324 /* Signal the waiter so that it leaves the futex. */ 1325 ATF_REQUIRE(_lwp_kill(lwp_data[0].threadid, SIGUSR1) == 0); 1326 1327 /* Yay! No panic! */ 1328 1329 reap_lwp_waiter(&lwp_data[0]); 1330 } 1331 1332 ATF_TC_WITH_CLEANUP(futex_wait_evil_unmapped_anon); 1333 ATF_TC_HEAD(futex_wait_evil_unmapped_anon, tc) 1334 { 1335 atf_tc_set_md_var(tc, "descr", 1336 "tests futex WAIT while futex is unmapped - anon memory"); 1337 } 1338 ATF_TC_BODY(futex_wait_evil_unmapped_anon, tc) 1339 { 1340 do_futex_wait_evil_unmapped(MAP_ANON); 1341 } 1342 ATF_TC_CLEANUP(futex_wait_evil_unmapped_anon, tc) 1343 { 1344 signal(SIGUSR1, old_act); 1345 do_cleanup(); 1346 } 1347 1348 /*****************************************************************************/ 1349 1350 static int pri_min; 1351 static int pri_max; 1352 1353 static void 1354 lowpri_simple_test_waiter_lwp(void *arg) 1355 { 1356 struct lwp_data *d = arg; 1357 struct sched_param sp; 1358 int policy; 1359 1360 d->threadid = _lwp_self(); 1361 1362 ATF_REQUIRE(_sched_getparam(getpid(), d->threadid, &policy, &sp) == 0); 1363 policy = SCHED_RR; 1364 sp.sched_priority = pri_min; 1365 ATF_REQUIRE(_sched_setparam(getpid(), d->threadid, policy, &sp) == 0); 1366 1367 simple_test_waiter_lwp(arg); 1368 } 1369 1370 static void 1371 highpri_simple_test_waiter_lwp(void *arg) 1372 { 1373 struct lwp_data *d = arg; 1374 struct sched_param sp; 1375 int policy; 1376 1377 d->threadid = _lwp_self(); 1378 1379 ATF_REQUIRE(_sched_getparam(getpid(), d->threadid, &policy, &sp) == 0); 1380 policy = SCHED_RR; 1381 sp.sched_priority = pri_max; 1382 ATF_REQUIRE(_sched_setparam(getpid(), d->threadid, policy, &sp) == 0); 1383 1384 simple_test_waiter_lwp(arg); 1385 } 1386 1387 static void 1388 do_test_wake_highest_pri(void) 1389 { 1390 lwpid_t waiter; 1391 int tries; 1392 long pri; 1393 1394 ATF_REQUIRE((pri = sysconf(_SC_SCHED_PRI_MIN)) != -1); 1395 pri_min = (int)pri; 1396 ATF_REQUIRE((pri = sysconf(_SC_SCHED_PRI_MAX)) != -1); 1397 pri_max = (int)pri; 1398 1399 futex_word = 0; 1400 membar_sync(); 1401 1402 setup_lwp_context(&lwp_data[0], lowpri_simple_test_waiter_lwp); 1403 lwp_data[0].op_flags = FUTEX_PRIVATE_FLAG; 1404 lwp_data[0].futex_error = -1; 1405 lwp_data[0].futex_ptr = &futex_word; 1406 lwp_data[0].block_val = 0; 1407 lwp_data[0].bitset = 0; 1408 lwp_data[0].wait_op = FUTEX_WAIT; 1409 ATF_REQUIRE(_lwp_create(&lwp_data[0].context, 0, 1410 &lwp_data[0].lwpid) == 0); 1411 1412 for (tries = 0; tries < 5; tries++) { 1413 membar_sync(); 1414 if (nlwps_running == 1) 1415 break; 1416 sleep(1); 1417 } 1418 membar_sync(); 1419 ATF_REQUIRE_EQ_MSG(nlwps_running, 1, "lowpri waiter failed to start"); 1420 1421 /* Ensure it's blocked. */ 1422 ATF_REQUIRE(lwp_data[0].futex_error == -1); 1423 1424 setup_lwp_context(&lwp_data[1], highpri_simple_test_waiter_lwp); 1425 lwp_data[1].op_flags = FUTEX_PRIVATE_FLAG; 1426 lwp_data[1].futex_error = -1; 1427 lwp_data[1].futex_ptr = &futex_word; 1428 lwp_data[1].block_val = 0; 1429 lwp_data[1].bitset = 0; 1430 lwp_data[1].wait_op = FUTEX_WAIT; 1431 ATF_REQUIRE(_lwp_create(&lwp_data[1].context, 0, 1432 &lwp_data[1].lwpid) == 0); 1433 1434 for (tries = 0; tries < 5; tries++) { 1435 membar_sync(); 1436 if (nlwps_running == 2) 1437 break; 1438 sleep(1); 1439 } 1440 membar_sync(); 1441 ATF_REQUIRE_EQ_MSG(nlwps_running, 2, "highpri waiter failed to start"); 1442 1443 /* Ensure it's blocked. */ 1444 ATF_REQUIRE(lwp_data[1].futex_error == -1); 1445 1446 /* Wake the first LWP. We should get the highpri thread. */ 1447 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1448 1, NULL, NULL, 0, 0) == 1); 1449 sleep(1); 1450 for (tries = 0; tries < 5; tries++) { 1451 membar_sync(); 1452 if (nlwps_running == 1) 1453 break; 1454 sleep(1); 1455 } 1456 membar_sync(); 1457 ATF_REQUIRE(nlwps_running == 1); 1458 ATF_REQUIRE(_lwp_wait(0, &waiter) == 0); 1459 ATF_REQUIRE(waiter == lwp_data[1].threadid); 1460 1461 /* Wake the second LWP. We should get the lowpri thread. */ 1462 ATF_REQUIRE(__futex(&futex_word, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1463 1, NULL, NULL, 0, 0) == 1); 1464 sleep(1); 1465 for (tries = 0; tries < 5; tries++) { 1466 membar_sync(); 1467 if (nlwps_running == 0) 1468 break; 1469 sleep(1); 1470 } 1471 membar_sync(); 1472 ATF_REQUIRE(nlwps_running == 0); 1473 ATF_REQUIRE(_lwp_wait(0, &waiter) == 0); 1474 ATF_REQUIRE(waiter == lwp_data[0].threadid); 1475 } 1476 1477 ATF_TC_WITH_CLEANUP(futex_wake_highest_pri); 1478 ATF_TC_HEAD(futex_wake_highest_pri, tc) 1479 { 1480 atf_tc_set_md_var(tc, "descr", 1481 "tests that futex WAKE wakes the highest priority waiter"); 1482 atf_tc_set_md_var(tc, "require.user", "root"); 1483 } 1484 ATF_TC_BODY(futex_wake_highest_pri, tc) 1485 { 1486 do_test_wake_highest_pri(); 1487 } 1488 ATF_TC_CLEANUP(futex_wake_highest_pri, tc) 1489 { 1490 do_cleanup(); 1491 } 1492 1493 /*****************************************************************************/ 1494 1495 ATF_TP_ADD_TCS(tp) 1496 { 1497 ATF_TP_ADD_TC(tp, futex_basic_wait_wake_private); 1498 ATF_TP_ADD_TC(tp, futex_basic_wait_wake_shared); 1499 ATF_TP_ADD_TC(tp, futex_wait_wake_anon_bs_private); 1500 ATF_TP_ADD_TC(tp, futex_wait_wake_anon_bs_shared); 1501 ATF_TP_ADD_TC(tp, futex_wait_wake_file_bs_private); 1502 ATF_TP_ADD_TC(tp, futex_wait_wake_file_bs_shared); 1503 ATF_TP_ADD_TC(tp, futex_wait_wake_file_bs_cow_private); 1504 ATF_TP_ADD_TC(tp, futex_wait_wake_file_bs_cow_shared); 1505 1506 ATF_TP_ADD_TC(tp, futex_wait_wake_anon_bs_shared_proc); 1507 ATF_TP_ADD_TC(tp, futex_wait_wake_file_bs_shared_proc); 1508 1509 ATF_TP_ADD_TC(tp, futex_wait_pointless_bitset); 1510 ATF_TP_ADD_TC(tp, futex_wait_wake_bitset); 1511 1512 ATF_TP_ADD_TC(tp, futex_wait_timeout_relative); 1513 ATF_TP_ADD_TC(tp, futex_wait_timeout_relative_rt); 1514 ATF_TP_ADD_TC(tp, futex_wait_timeout_deadline); 1515 ATF_TP_ADD_TC(tp, futex_wait_timeout_deadline_rt); 1516 1517 ATF_TP_ADD_TC(tp, futex_wait_evil_unmapped_anon); 1518 1519 ATF_TP_ADD_TC(tp, futex_requeue); 1520 ATF_TP_ADD_TC(tp, futex_cmp_requeue); 1521 1522 ATF_TP_ADD_TC(tp, futex_wake_op_op); 1523 ATF_TP_ADD_TC(tp, futex_wake_op_cmp); 1524 1525 ATF_TP_ADD_TC(tp, futex_wake_highest_pri); 1526 1527 return atf_no_error(); 1528 } 1529
Indexes created Fri Sep 26 08:10:20 GMT 2025