1 /* $NetBSD: t_mutex.c,v 1.15 2017/01/16 16:23:41 christos Exp $ */ 2 3 /* 4 * Copyright (c) 2008 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) 2008\ 31 The NetBSD Foundation, inc. All rights reserved."); 32 __RCSID("$NetBSD: t_mutex.c,v 1.15 2017/01/16 16:23:41 christos Exp $"); 33 34 #include <sys/time.h> /* For timespecadd */ 35 #include <inttypes.h> /* For UINT16_MAX */ 36 #include <pthread.h> 37 #include <stdio.h> 38 #include <string.h> 39 #include <errno.h> 40 #include <time.h> 41 #include <unistd.h> 42 #include <sys/sched.h> 43 #include <sys/param.h> 44 45 #include <atf-c.h> 46 47 #include "h_common.h" 48 49 static pthread_mutex_t mutex; 50 static pthread_mutex_t static_mutex = PTHREAD_MUTEX_INITIALIZER; 51 static int global_x; 52 53 #ifdef TIMEDMUTEX 54 /* This code is used for verifying non-timed specific code */ 55 static struct timespec ts_lengthy = { 56 .tv_sec = UINT16_MAX, 57 .tv_nsec = 0 58 }; 59 /* This code is used for verifying timed-only specific code */ 60 static struct timespec ts_shortlived = { 61 .tv_sec = 0, 62 .tv_nsec = 120 63 }; 64 65 static int 66 mutex_lock(pthread_mutex_t *m, const struct timespec *ts) 67 { 68 struct timespec ts_wait; 69 ATF_REQUIRE(clock_gettime(CLOCK_REALTIME, &ts_wait) != -1); 70 timespecadd(&ts_wait, ts, &ts_wait); 71 72 return pthread_mutex_timedlock(m, &ts_wait); 73 } 74 #else 75 #define mutex_lock(a, b) pthread_mutex_lock(a) 76 #endif 77 78 static void * 79 mutex1_threadfunc(void *arg) 80 { 81 int *param; 82 83 printf("2: Second thread.\n"); 84 85 param = arg; 86 printf("2: Locking mutex\n"); 87 mutex_lock(&mutex, &ts_lengthy); 88 printf("2: Got mutex. *param = %d\n", *param); 89 ATF_REQUIRE_EQ(*param, 20); 90 (*param)++; 91 92 pthread_mutex_unlock(&mutex); 93 94 return param; 95 } 96 97 ATF_TC(mutex1); 98 ATF_TC_HEAD(mutex1, tc) 99 { 100 atf_tc_set_md_var(tc, "descr", "Checks mutexes"); 101 } 102 ATF_TC_BODY(mutex1, tc) 103 { 104 int x; 105 pthread_t new; 106 void *joinval; 107 108 printf("1: Mutex-test 1\n"); 109 110 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL)); 111 x = 1; 112 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 113 PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex1_threadfunc, &x)); 114 printf("1: Before changing the value.\n"); 115 sleep(2); 116 x = 20; 117 printf("1: Before releasing the mutex.\n"); 118 sleep(2); 119 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 120 printf("1: After releasing the mutex.\n"); 121 PTHREAD_REQUIRE(pthread_join(new, &joinval)); 122 123 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 124 printf("1: Thread joined. X was %d. Return value (int) was %d\n", 125 x, *(int *)joinval); 126 ATF_REQUIRE_EQ(x, 21); 127 ATF_REQUIRE_EQ(*(int *)joinval, 21); 128 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 129 } 130 131 static void * 132 mutex2_threadfunc(void *arg) 133 { 134 long count = *(int *)arg; 135 136 printf("2: Second thread (%p). Count is %ld\n", pthread_self(), count); 137 138 while (count--) { 139 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 140 global_x++; 141 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 142 } 143 144 return (void *)count; 145 } 146 147 ATF_TC(mutex2); 148 ATF_TC_HEAD(mutex2, tc) 149 { 150 atf_tc_set_md_var(tc, "descr", "Checks mutexes"); 151 #ifdef __NetBSD__ 152 #if defined(__powerpc__) 153 atf_tc_set_md_var(tc, "timeout", "40"); 154 #endif 155 #endif 156 157 #ifdef __FreeBSD__ 158 #if defined(__riscv) 159 atf_tc_set_md_var(tc, "timeout", "600"); 160 #endif 161 #endif 162 } 163 ATF_TC_BODY(mutex2, tc) 164 { 165 int count, count2; 166 pthread_t new; 167 void *joinval; 168 169 printf("1: Mutex-test 2\n"); 170 171 #ifdef __NetBSD__ 172 #if defined(__powerpc__) 173 atf_tc_expect_timeout("PR port-powerpc/44387"); 174 #endif 175 #endif 176 177 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL)); 178 179 global_x = 0; 180 count = count2 = 10000000; 181 182 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 183 PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex2_threadfunc, &count2)); 184 185 printf("1: Thread %p\n", pthread_self()); 186 187 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 188 189 while (count--) { 190 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 191 global_x++; 192 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 193 } 194 195 PTHREAD_REQUIRE(pthread_join(new, &joinval)); 196 197 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 198 printf("1: Thread joined. X was %d. Return value (long) was %ld\n", 199 global_x, (long)joinval); 200 ATF_REQUIRE_EQ(global_x, 20000000); 201 202 #ifdef __NetBSD__ 203 #if defined(__powerpc__) 204 /* XXX force a timeout in ppc case since an un-triggered race 205 otherwise looks like a "failure" */ 206 /* We sleep for longer than the timeout to make ATF not 207 complain about unexpected success */ 208 sleep(41); 209 #endif 210 #endif 211 } 212 213 static void * 214 mutex3_threadfunc(void *arg) 215 { 216 long count = *(int *)arg; 217 218 printf("2: Second thread (%p). Count is %ld\n", pthread_self(), count); 219 220 while (count--) { 221 PTHREAD_REQUIRE(mutex_lock(&static_mutex, &ts_lengthy)); 222 global_x++; 223 PTHREAD_REQUIRE(pthread_mutex_unlock(&static_mutex)); 224 } 225 226 return (void *)count; 227 } 228 229 ATF_TC(mutex3); 230 ATF_TC_HEAD(mutex3, tc) 231 { 232 atf_tc_set_md_var(tc, "descr", "Checks mutexes using a static " 233 "initializer"); 234 #ifdef __NetBSD__ 235 #if defined(__powerpc__) 236 atf_tc_set_md_var(tc, "timeout", "40"); 237 #endif 238 #endif 239 240 #ifdef __FreeBSD__ 241 #if defined(__riscv) 242 atf_tc_set_md_var(tc, "timeout", "600"); 243 #endif 244 #endif 245 } 246 ATF_TC_BODY(mutex3, tc) 247 { 248 int count, count2; 249 pthread_t new; 250 void *joinval; 251 252 printf("1: Mutex-test 3\n"); 253 254 #ifdef __NetBSD__ 255 #if defined(__powerpc__) 256 atf_tc_expect_timeout("PR port-powerpc/44387"); 257 #endif 258 #endif 259 260 global_x = 0; 261 count = count2 = 10000000; 262 263 PTHREAD_REQUIRE(mutex_lock(&static_mutex, &ts_lengthy)); 264 PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex3_threadfunc, &count2)); 265 266 printf("1: Thread %p\n", pthread_self()); 267 268 PTHREAD_REQUIRE(pthread_mutex_unlock(&static_mutex)); 269 270 while (count--) { 271 PTHREAD_REQUIRE(mutex_lock(&static_mutex, &ts_lengthy)); 272 global_x++; 273 PTHREAD_REQUIRE(pthread_mutex_unlock(&static_mutex)); 274 } 275 276 PTHREAD_REQUIRE(pthread_join(new, &joinval)); 277 278 PTHREAD_REQUIRE(mutex_lock(&static_mutex, &ts_lengthy)); 279 printf("1: Thread joined. X was %d. Return value (long) was %ld\n", 280 global_x, (long)joinval); 281 ATF_REQUIRE_EQ(global_x, 20000000); 282 283 #ifdef __NetBSD__ 284 #if defined(__powerpc__) 285 /* XXX force a timeout in ppc case since an un-triggered race 286 otherwise looks like a "failure" */ 287 /* We sleep for longer than the timeout to make ATF not 288 complain about unexpected success */ 289 sleep(41); 290 #endif 291 #endif 292 } 293 294 static void * 295 mutex4_threadfunc(void *arg) 296 { 297 int *param; 298 299 printf("2: Second thread.\n"); 300 301 param = arg; 302 printf("2: Locking mutex\n"); 303 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 304 printf("2: Got mutex. *param = %d\n", *param); 305 (*param)++; 306 307 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 308 309 return param; 310 } 311 312 ATF_TC(mutex4); 313 ATF_TC_HEAD(mutex4, tc) 314 { 315 atf_tc_set_md_var(tc, "descr", "Checks mutexes"); 316 } 317 ATF_TC_BODY(mutex4, tc) 318 { 319 int x; 320 pthread_t new; 321 pthread_mutexattr_t mattr; 322 void *joinval; 323 324 printf("1: Mutex-test 4\n"); 325 326 PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr)); 327 PTHREAD_REQUIRE(pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE)); 328 329 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, &mattr)); 330 331 PTHREAD_REQUIRE(pthread_mutexattr_destroy(&mattr)); 332 333 x = 1; 334 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 335 PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex4_threadfunc, &x)); 336 337 printf("1: Before recursively acquiring the mutex.\n"); 338 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 339 340 printf("1: Before releasing the mutex once.\n"); 341 sleep(2); 342 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 343 printf("1: After releasing the mutex once.\n"); 344 345 x = 20; 346 347 printf("1: Before releasing the mutex twice.\n"); 348 sleep(2); 349 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 350 printf("1: After releasing the mutex twice.\n"); 351 352 PTHREAD_REQUIRE(pthread_join(new, &joinval)); 353 354 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 355 printf("1: Thread joined. X was %d. Return value (int) was %d\n", 356 x, *(int *)joinval); 357 ATF_REQUIRE_EQ(x, 21); 358 ATF_REQUIRE_EQ(*(int *)joinval, 21); 359 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 360 } 361 362 #ifdef __NetBSD__ 363 static pthread_mutexattr_t attr5; 364 static pthread_mutex_t mutex5; 365 static int min_fifo_prio, max_fifo_prio; 366 367 static void * 368 child_func(void* arg) 369 { 370 int res; 371 372 printf("child is waiting\n"); 373 res = _sched_protect(-2); 374 ATF_REQUIRE_EQ_MSG(res, -1, "sched_protect returned %d", res); 375 ATF_REQUIRE_EQ(errno, ENOENT); 376 PTHREAD_REQUIRE(mutex_lock(&mutex5, &ts_lengthy)); 377 printf("child is owning resource\n"); 378 res = _sched_protect(-2); 379 ATF_REQUIRE_EQ(res, max_fifo_prio); 380 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex5)); 381 printf("child is done\n"); 382 383 return 0; 384 } 385 386 ATF_TC(mutex5); 387 ATF_TC_HEAD(mutex5, tc) 388 { 389 atf_tc_set_md_var(tc, "descr", "Checks mutexes for priority setting"); 390 atf_tc_set_md_var(tc, "require.user", "root"); 391 } 392 393 ATF_TC_BODY(mutex5, tc) 394 { 395 int res; 396 struct sched_param param; 397 pthread_t child; 398 399 min_fifo_prio = sched_get_priority_min(SCHED_FIFO); 400 max_fifo_prio = sched_get_priority_max(SCHED_FIFO); 401 printf("min prio for FIFO = %d\n", min_fifo_prio); 402 param.sched_priority = min_fifo_prio; 403 404 /* = 0 OTHER, 1 FIFO, 2 RR, -1 NONE */ 405 res = sched_setscheduler(getpid(), SCHED_FIFO, ¶m); 406 printf("previous policy used = %d\n", res); 407 408 res = sched_getscheduler(getpid()); 409 ATF_REQUIRE_EQ_MSG(res, SCHED_FIFO, "sched %d != FIFO %d", res, 410 SCHED_FIFO); 411 412 PTHREAD_REQUIRE(pthread_mutexattr_init(&attr5)); 413 PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&attr5, 414 PTHREAD_PRIO_PROTECT)); 415 PTHREAD_REQUIRE(pthread_mutexattr_setprioceiling(&attr5, 416 max_fifo_prio)); 417 418 PTHREAD_REQUIRE(pthread_mutex_init(&mutex5, &attr5)); 419 PTHREAD_REQUIRE(mutex_lock(&mutex5, &ts_lengthy)); 420 printf("enter critical section for main\n"); 421 PTHREAD_REQUIRE(pthread_create(&child, NULL, child_func, NULL)); 422 printf("main starts to sleep\n"); 423 sleep(10); 424 printf("main completes\n"); 425 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex5)); 426 PTHREAD_REQUIRE(pthread_join(child, NULL)); 427 } 428 429 static pthread_mutex_t mutex6; 430 static int start = 0; 431 static uintmax_t high_cnt = 0, low_cnt = 0, MAX_LOOP = 100000000; 432 433 static void * 434 high_prio(void* arg) 435 { 436 struct sched_param param; 437 int policy; 438 param.sched_priority = min_fifo_prio + 10; 439 pthread_t childid = pthread_self(); 440 441 PTHREAD_REQUIRE(pthread_setschedparam(childid, 1, ¶m)); 442 PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, ¶m)); 443 printf("high protect = %d, prio = %d\n", 444 _sched_protect(-2), param.sched_priority); 445 ATF_REQUIRE_EQ(policy, 1); 446 printf("high prio = %d\n", param.sched_priority); 447 sleep(1); 448 long tmp = 0; 449 for (int i = 0; i < 20; i++) { 450 while (high_cnt < MAX_LOOP) { 451 tmp += (123456789 % 1234) * (987654321 % 54321); 452 high_cnt += 1; 453 } 454 high_cnt = 0; 455 sleep(1); 456 } 457 PTHREAD_REQUIRE(mutex_lock(&mutex6, &ts_lengthy)); 458 if (start == 0) start = 2; 459 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex6)); 460 461 return 0; 462 } 463 464 static void * 465 low_prio(void* arg) 466 { 467 struct sched_param param; 468 int policy; 469 param.sched_priority = min_fifo_prio; 470 pthread_t childid = pthread_self(); 471 int res = _sched_protect(max_fifo_prio); 472 ATF_REQUIRE_EQ(res, 0); 473 PTHREAD_REQUIRE(pthread_setschedparam(childid, 1, ¶m)); 474 PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, ¶m)); 475 printf("low protect = %d, prio = %d\n", _sched_protect(-2), 476 param.sched_priority); 477 ATF_REQUIRE_EQ(policy, 1); 478 printf("low prio = %d\n", param.sched_priority); 479 sleep(1); 480 long tmp = 0; 481 for (int i = 0; i < 20; i++) { 482 while (low_cnt < MAX_LOOP) { 483 tmp += (123456789 % 1234) * (987654321 % 54321); 484 low_cnt += 1; 485 } 486 low_cnt = 0; 487 sleep(1); 488 } 489 PTHREAD_REQUIRE(mutex_lock(&mutex6, &ts_lengthy)); 490 if (start == 0) 491 start = 1; 492 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex6)); 493 494 return 0; 495 } 496 497 ATF_TC(mutex6); 498 ATF_TC_HEAD(mutex6, tc) 499 { 500 atf_tc_set_md_var(tc, "descr", 501 "Checks scheduling for priority ceiling"); 502 atf_tc_set_md_var(tc, "require.user", "root"); 503 } 504 505 /* 506 * 1. main thread sets itself to be a realtime task and launched two tasks, 507 * one has higher priority and the other has lower priority. 508 * 2. each child thread(low and high priority thread) sets its scheduler and 509 * priority. 510 * 3. each child thread did several rounds of computation, after each round it 511 * sleep 1 second. 512 * 4. the child thread with low priority will call _sched_protect to increase 513 * its protect priority. 514 * 5. We verify the thread with low priority runs first. 515 * 516 * Why does it work? From the main thread, we launched the high 517 * priority thread first. This gives this thread the benefit of 518 * starting first. The low priority thread did not call _sched_protect(2). 519 * The high priority thread should finish the task first. After each 520 * round of computation, we call sleep, to put the task into the 521 * sleep queue, and wake up again after the timer expires. This 522 * gives the scheduler the chance to decide which task to run. So, 523 * the thread with real high priority will always block the thread 524 * with real low priority. 525 * 526 */ 527 ATF_TC_BODY(mutex6, tc) 528 { 529 struct sched_param param; 530 int res; 531 pthread_t high, low; 532 533 min_fifo_prio = sched_get_priority_min(SCHED_FIFO); 534 max_fifo_prio = sched_get_priority_max(SCHED_FIFO); 535 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL)); 536 printf("min_fifo_prio = %d, max_fifo_info = %d\n", min_fifo_prio, 537 max_fifo_prio); 538 539 param.sched_priority = min_fifo_prio; 540 res = sched_setscheduler(getpid(), SCHED_FIFO, ¶m); 541 printf("previous policy used = %d\n", res); 542 543 res = sched_getscheduler(getpid()); 544 ATF_REQUIRE_EQ(res, 1); 545 PTHREAD_REQUIRE(pthread_create(&high, NULL, high_prio, NULL)); 546 PTHREAD_REQUIRE(pthread_create(&low, NULL, low_prio, NULL)); 547 sleep(5); 548 PTHREAD_REQUIRE(pthread_join(low, NULL)); 549 PTHREAD_REQUIRE(pthread_join(high, NULL)); 550 551 ATF_REQUIRE_EQ(start, 1); 552 } 553 #endif 554 555 ATF_TC(mutexattr1); 556 ATF_TC_HEAD(mutexattr1, tc) 557 { 558 atf_tc_set_md_var(tc, "descr", "Checks mutexattr"); 559 } 560 561 ATF_TC_BODY(mutexattr1, tc) 562 { 563 pthread_mutexattr_t mattr; 564 int protocol, target; 565 566 PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr)); 567 568 target = PTHREAD_PRIO_NONE; 569 PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target)); 570 PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol)); 571 ATF_REQUIRE_EQ(protocol, target); 572 573 /* 574 target = PTHREAD_PRIO_INHERIT; 575 PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target)); 576 PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol)); 577 ATF_REQUIRE_EQ(protocol, target); 578 */ 579 580 target = PTHREAD_PRIO_PROTECT; 581 PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target)); 582 PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol)); 583 ATF_REQUIRE_EQ(protocol, target); 584 } 585 586 ATF_TC(mutexattr2); 587 ATF_TC_HEAD(mutexattr2, tc) 588 { 589 atf_tc_set_md_var(tc, "descr", "Checks mutexattr"); 590 } 591 592 ATF_TC_BODY(mutexattr2, tc) 593 { 594 pthread_mutexattr_t mattr; 595 596 #ifdef __FreeBSD__ 597 atf_tc_expect_fail("fails on i == 0 with: " 598 "pthread_mutexattr_setprioceiling(&mattr, i): Invalid argument " 599 "-- PR # 211802"); 600 #endif 601 602 PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr)); 603 int max_prio = sched_get_priority_max(SCHED_FIFO); 604 int min_prio = sched_get_priority_min(SCHED_FIFO); 605 for (int i = min_prio; i <= max_prio; i++) { 606 int prioceiling; 607 int protocol; 608 609 PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, 610 &protocol)); 611 612 printf("priority: %d\nprotocol: %d\n", i, protocol); 613 PTHREAD_REQUIRE(pthread_mutexattr_setprioceiling(&mattr, i)); 614 PTHREAD_REQUIRE(pthread_mutexattr_getprioceiling(&mattr, 615 &prioceiling)); 616 printf("prioceiling: %d\n", prioceiling); 617 ATF_REQUIRE_EQ(i, prioceiling); 618 } 619 } 620 621 #ifdef TIMEDMUTEX 622 ATF_TC(timedmutex1); 623 ATF_TC_HEAD(timedmutex1, tc) 624 { 625 atf_tc_set_md_var(tc, "descr", "Checks timeout on selflock"); 626 } 627 628 ATF_TC_BODY(timedmutex1, tc) 629 { 630 631 printf("Timed mutex-test 1\n"); 632 633 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL)); 634 635 printf("Before acquiring mutex\n"); 636 PTHREAD_REQUIRE(pthread_mutex_lock(&mutex)); 637 638 printf("Before endeavor to reacquire timed-mutex (timeout expected)\n"); 639 PTHREAD_REQUIRE_STATUS(mutex_lock(&mutex, &ts_shortlived), 640 ETIMEDOUT); 641 642 printf("Unlocking mutex\n"); 643 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 644 } 645 646 ATF_TC(timedmutex2); 647 ATF_TC_HEAD(timedmutex2, tc) 648 { 649 atf_tc_set_md_var(tc, "descr", 650 "Checks timeout on selflock with timedlock"); 651 } 652 653 ATF_TC_BODY(timedmutex2, tc) 654 { 655 656 printf("Timed mutex-test 2\n"); 657 658 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL)); 659 660 printf("Before acquiring mutex with timedlock\n"); 661 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 662 663 printf("Before endeavor to reacquire timed-mutex (timeout expected)\n"); 664 PTHREAD_REQUIRE_STATUS(mutex_lock(&mutex, &ts_shortlived), 665 ETIMEDOUT); 666 667 printf("Unlocking mutex\n"); 668 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 669 } 670 671 ATF_TC(timedmutex3); 672 ATF_TC_HEAD(timedmutex3, tc) 673 { 674 atf_tc_set_md_var(tc, "descr", 675 "Checks timeout on selflock in a new thread"); 676 } 677 678 static void * 679 timedmtx_thrdfunc(void *arg) 680 { 681 printf("Before endeavor to reacquire timed-mutex (timeout expected)\n"); 682 PTHREAD_REQUIRE_STATUS(mutex_lock(&mutex, &ts_shortlived), 683 ETIMEDOUT); 684 685 return NULL; 686 } 687 688 ATF_TC_BODY(timedmutex3, tc) 689 { 690 pthread_t new; 691 692 printf("Timed mutex-test 3\n"); 693 694 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL)); 695 696 printf("Before acquiring mutex with timedlock\n"); 697 PTHREAD_REQUIRE(pthread_mutex_lock(&mutex)); 698 699 printf("Before creating new thread\n"); 700 PTHREAD_REQUIRE(pthread_create(&new, NULL, timedmtx_thrdfunc, NULL)); 701 702 printf("Before joining the mutex\n"); 703 PTHREAD_REQUIRE(pthread_join(new, NULL)); 704 705 printf("Unlocking mutex\n"); 706 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 707 } 708 709 ATF_TC(timedmutex4); 710 ATF_TC_HEAD(timedmutex4, tc) 711 { 712 atf_tc_set_md_var(tc, "descr", 713 "Checks timeout on selflock with timedlock in a new thread"); 714 } 715 716 ATF_TC_BODY(timedmutex4, tc) 717 { 718 pthread_t new; 719 720 printf("Timed mutex-test 4\n"); 721 722 PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL)); 723 724 printf("Before acquiring mutex with timedlock\n"); 725 PTHREAD_REQUIRE(mutex_lock(&mutex, &ts_lengthy)); 726 727 printf("Before creating new thread\n"); 728 PTHREAD_REQUIRE(pthread_create(&new, NULL, timedmtx_thrdfunc, NULL)); 729 730 printf("Before joining the mutex\n"); 731 PTHREAD_REQUIRE(pthread_join(new, NULL)); 732 733 printf("Unlocking mutex\n"); 734 PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex)); 735 } 736 #endif 737 738 ATF_TP_ADD_TCS(tp) 739 { 740 ATF_TP_ADD_TC(tp, mutex1); 741 ATF_TP_ADD_TC(tp, mutex2); 742 ATF_TP_ADD_TC(tp, mutex3); 743 ATF_TP_ADD_TC(tp, mutex4); 744 #ifdef __NetBSD__ 745 ATF_TP_ADD_TC(tp, mutex5); 746 ATF_TP_ADD_TC(tp, mutex6); 747 #endif 748 ATF_TP_ADD_TC(tp, mutexattr1); 749 ATF_TP_ADD_TC(tp, mutexattr2); 750 751 #ifdef TIMEDMUTEX 752 ATF_TP_ADD_TC(tp, timedmutex1); 753 ATF_TP_ADD_TC(tp, timedmutex2); 754 ATF_TP_ADD_TC(tp, timedmutex3); 755 ATF_TP_ADD_TC(tp, timedmutex4); 756 #endif 757 758 return atf_no_error(); 759 } 760