xref: /freebsd/contrib/netbsd-tests/lib/libpthread/t_mutex.c (revision cddbc3b40812213ff00041f79174cac0be360a2a)
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, &param);
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, &param));
442 	PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, &param));
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, &param));
474 	PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, &param));
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, &param);
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