Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add new test t_timedmutex 

This test is a clone on t_mutex with additional two tests for timed-mutex
specific block.

All simple-mutex (not with the timed property according to the C11 wording)
specific tests are covered by pthread_mutex_timedlock(3) with parameter
ts_lengthy of sufficiently large tv_sec value (right now UINT16_MAX). If,
a test will hang, it won't wait UINT16_MAX seconds, but will be terminated
within the default timeout for ATF tests (right now 300 [sec] in my
NetBSD/amd64 setup).

This test was inspired by a classic selflock test failure of
pthread_mutex_timedlock(3) of the following form:

#include <assert.h>
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <time.h>

int main(int argc, char **argv)
{
	pthread_mutex_t mtx;
        struct timespec ts;

        ts.tv_sec = 0;
        ts.tv_nsec = 1000;
        printf("ts{.tv_sec = %d, .tv_nsec=%ld}\n", ts.tv_sec, ts.tv_nsec);
        fflush(stdout);

        printf("mtx_init\n");
	assert(pthread_mutex_init(&mtx, NULL) == 0);

        printf("mtx_lock\n");
	assert(pthread_mutex_lock(&mtx) == 0);

        printf("mtx_timedlock\n");
	assert(pthread_mutex_timedlock(&mtx, &ts) == ETIMEDOUT);

        printf("mtx_unlock\n");
	assert(pthread_mutex_unlock(&mtx) == 0);

	printf("mtx_destroy\n");
        assert(pthread_mutex_destroy(&mtx) == 0);

	return 0;
}

Current NetBSD implementation wrongly hangs on this test.

The issue was detected during development of the C11 portable threads.

My local tests in chroot presents that the are further issues:

t_timedmutex (21/25): 10 test cases
    mutex1: [0.001142s] Failed: /usr/src/tests/lib/libpthread/t_timedmutex.c:75: *param != 20
    mutex2: [0.261499s] Passed.
    mutex3: [0.261496s] Passed.
    mutex4: [0.001204s] Failed: /usr/src/tests/lib/libpthread/t_timedmutex.c:265: pthread_mutex_timedlock(&mutex, &ts_lengthy): Connection timed out
    mutex5: [0.001235s] Failed: /usr/src/tests/lib/libpthread/t_timedmutex.c:337: pthread_mutex_timedlock(&mutex5, &ts_lengthy): Connection timed out
    mutex6: [21.218497s] Failed: /usr/src/tests/lib/libpthread/t_timedmutex.c:512: start != 1
    mutexattr1: [0.001328s] Passed.
    mutexattr2: [0.001175s] Passed.
    timedmutex1: [301.119397s] Failed: Test case timed out after 300 seconds
    timedmutex2: [301.123081s] Failed: Test case timed out after 300 seconds
[623.990659s]

I'm also receiveing the same failure in the mutex6 test in t_mutex, so
there might be a false positives due to local chroot(8) issues.

Commit approved by <christos>.
This commit is contained in:
kamil 2016-10-30 16:17:16 +00:00
parent 6b3de624e6
commit 53e134ea9e
6 changed files with 650 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
distrib/sets/lists/debug/mi
View File

@ -1,4 +1,4 @@
# $NetBSD: mi,v 1.167 2016/09/05 02:25:38 ozaki-r Exp $
# $NetBSD: mi,v 1.168 2016/10/30 16:17:16 kamil Exp $
./etc/mtree/set.debug comp-sys-root
./usr/lib comp-sys-usr compatdir
./usr/lib/i18n/libBIG5_g.a comp-c-debuglib debuglib,compatfile
@ -2159,6 +2159,7 @@
./usr/libdata/debug/usr/tests/lib/libpthread/t_sleep.debug tests-lib-tests debug,atf,compattestfile
./usr/libdata/debug/usr/tests/lib/libpthread/t_status.debug tests-obsolete obsolete,compattestfile
./usr/libdata/debug/usr/tests/lib/libpthread/t_swapcontext.debug tests-lib-tests debug,atf,compattestfile
./usr/libdata/debug/usr/tests/lib/libpthread/t_timedmutex.debug tests-lib-tests debug,atf,compattestfile
./usr/libdata/debug/usr/tests/lib/librt/t_sched.debug tests-lib-debug debug,atf,compattestfile
./usr/libdata/debug/usr/tests/lib/librt/t_sem.debug tests-lib-debug debug,atf,compattestfile
./usr/libdata/debug/usr/tests/lib/librumpclient/h_exec.debug tests-lib-debug debug,atf,rump

3
distrib/sets/lists/tests/mi
View File

@ -1,4 +1,4 @@
# $NetBSD: mi,v 1.688 2016/10/22 14:13:39 abhinav Exp $
# $NetBSD: mi,v 1.689 2016/10/30 16:17:16 kamil Exp $
#
# Note: don't delete entries from here - mark them as "obsolete" instead.
#
@ -3000,6 +3000,7 @@
./usr/tests/lib/libpthread/t_sleep tests-lib-tests compattestfile,atf
./usr/tests/lib/libpthread/t_status tests-obsolete obsolete
./usr/tests/lib/libpthread/t_swapcontext tests-lib-tests compattestfile,atf
./usr/tests/lib/libpthread/t_timedmutex tests-lib-tests compattestfile,atf
./usr/tests/lib/librt tests-lib-tests compattestfile,atf
./usr/tests/lib/librt/Atffile tests-lib-tests compattestfile,atf
./usr/tests/lib/librt/Kyuafile tests-lib-tests compattestfile,atf,kyua

3
tests/lib/libpthread/Makefile
View File

@ -1,4 +1,4 @@
# $NetBSD: Makefile,v 1.11 2013/04/12 17:18:11 christos Exp $
# $NetBSD: Makefile,v 1.12 2016/10/30 16:17:16 kamil Exp $
NOMAN= # defined
@ -38,6 +38,7 @@ TESTS_C+= t_sigsuspend
TESTS_C+= t_siglongjmp
TESTS_C+= t_sleep
TESTS_C+= t_swapcontext
TESTS_C+= t_timedmutex
LDADD.t_sem+= -lrt

6
tests/lib/libpthread/h_common.h
View File

@ -9,4 +9,10 @@
ATF_REQUIRE_MSG(ret == 0, "%s: %s", #x, strerror(ret)); \
} while (0)
#define PTHREAD_REQUIRE_STATUS(x, v) \
do { \
int ret = (x); \
ATF_REQUIRE_MSG(ret == (v), "%s: %s", #x, strerror(ret)); \
} while (0)
#endif // H_COMMON_H

6
tests/lib/libpthread/t_mutex.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: t_mutex.c,v 1.10 2016/07/31 13:01:29 christos Exp $ */
/* $NetBSD: t_mutex.c,v 1.11 2016/10/30 16:17:16 kamil Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
@ -26,10 +26,12 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
/* Please sync code from this test with t_timedmutex.c */
#include <sys/cdefs.h>
__COPYRIGHT("@(#) Copyright (c) 2008\
The NetBSD Foundation, inc. All rights reserved.");
__RCSID("$NetBSD: t_mutex.c,v 1.10 2016/07/31 13:01:29 christos Exp $");
__RCSID("$NetBSD: t_mutex.c,v 1.11 2016/10/30 16:17:16 kamil Exp $");
#include <pthread.h>
#include <stdio.h>

634
tests/lib/libpthread/t_timedmutex.c Normal file
View File

@ -0,0 +1,634 @@
/* $NetBSD: t_timedmutex.c,v 1.1 2016/10/30 16:17:16 kamil Exp $ */
/*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/* Please sync code from this test with t_mutex.c unless it's timed specific */
#include <sys/cdefs.h>
__COPYRIGHT("@(#) Copyright (c) 2008\
The NetBSD Foundation, inc. All rights reserved.");
__RCSID("$NetBSD: t_timedmutex.c,v 1.1 2016/10/30 16:17:16 kamil Exp $");
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <sys/sched.h>
#include <sys/param.h>
#include <atf-c.h>
#include "h_common.h"
static pthread_mutex_t mutex;
static pthread_mutex_t static_mutex = PTHREAD_MUTEX_INITIALIZER;
static int global_x;
/* This code is used for verifying non-timed specific code */
static struct timespec ts_lengthy = {
.tv_sec = UINT16_MAX,
.tv_nsec = 0
};
/* This code is used for verifying timed-only specific code */
static struct timespec ts_shortlived = {
.tv_sec = 0,
.tv_nsec = 120
};
static void *
mutex1_threadfunc(void *arg)
{
int *param;
printf("2: Second thread.\n");
param = arg;
printf("2: Locking mutex\n");
pthread_mutex_timedlock(&mutex, &ts_lengthy);
printf("2: Got mutex. *param = %d\n", *param);
ATF_REQUIRE_EQ(*param, 20);
(*param)++;
pthread_mutex_unlock(&mutex);
return param;
}
ATF_TC(mutex1);
ATF_TC_HEAD(mutex1, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks mutexes");
}
ATF_TC_BODY(mutex1, tc)
{
int x;
pthread_t new;
void *joinval;
printf("1: Mutex-test 1\n");
PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL));
x = 1;
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex1_threadfunc, &x));
printf("1: Before changing the value.\n");
sleep(2);
x = 20;
printf("1: Before releasing the mutex.\n");
sleep(2);
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
printf("1: After releasing the mutex.\n");
PTHREAD_REQUIRE(pthread_join(new, &joinval));
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
printf("1: Thread joined. X was %d. Return value (int) was %d\n",
x, *(int *)joinval);
ATF_REQUIRE_EQ(x, 21);
ATF_REQUIRE_EQ(*(int *)joinval, 21);
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
}
static void *
mutex2_threadfunc(void *arg)
{
long count = *(int *)arg;
printf("2: Second thread (%p). Count is %ld\n", pthread_self(), count);
while (count--) {
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
global_x++;
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
}
return (void *)count;
}
ATF_TC(mutex2);
ATF_TC_HEAD(mutex2, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks mutexes");
#if defined(__powerpc__)
atf_tc_set_md_var(tc, "timeout", "40");
#endif
}
ATF_TC_BODY(mutex2, tc)
{
int count, count2;
pthread_t new;
void *joinval;
printf("1: Mutex-test 2\n");
#if defined(__powerpc__)
atf_tc_expect_timeout("PR port-powerpc/44387");
#endif
PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL));
global_x = 0;
count = count2 = 10000000;
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex2_threadfunc, &count2));
printf("1: Thread %p\n", pthread_self());
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
while (count--) {
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
global_x++;
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
}
PTHREAD_REQUIRE(pthread_join(new, &joinval));
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
printf("1: Thread joined. X was %d. Return value (long) was %ld\n",
global_x, (long)joinval);
ATF_REQUIRE_EQ(global_x, 20000000);
#if defined(__powerpc__)
/* XXX force a timeout in ppc case since an un-triggered race
otherwise looks like a "failure" */
/* We sleep for longer than the timeout to make ATF not
complain about unexpected success */
sleep(41);
#endif
}
static void *
mutex3_threadfunc(void *arg)
{
long count = *(int *)arg;
printf("2: Second thread (%p). Count is %ld\n", pthread_self(), count);
while (count--) {
PTHREAD_REQUIRE(pthread_mutex_timedlock(&static_mutex, &ts_lengthy));
global_x++;
PTHREAD_REQUIRE(pthread_mutex_unlock(&static_mutex));
}
return (void *)count;
}
ATF_TC(mutex3);
ATF_TC_HEAD(mutex3, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks mutexes using a static "
"initializer");
#if defined(__powerpc__)
atf_tc_set_md_var(tc, "timeout", "40");
#endif
}
ATF_TC_BODY(mutex3, tc)
{
int count, count2;
pthread_t new;
void *joinval;
printf("1: Mutex-test 3\n");
#if defined(__powerpc__)
atf_tc_expect_timeout("PR port-powerpc/44387");
#endif
global_x = 0;
count = count2 = 10000000;
PTHREAD_REQUIRE(pthread_mutex_timedlock(&static_mutex, &ts_lengthy));
PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex3_threadfunc, &count2));
printf("1: Thread %p\n", pthread_self());
PTHREAD_REQUIRE(pthread_mutex_unlock(&static_mutex));
while (count--) {
PTHREAD_REQUIRE(pthread_mutex_timedlock(&static_mutex, &ts_lengthy));
global_x++;
PTHREAD_REQUIRE(pthread_mutex_unlock(&static_mutex));
}
PTHREAD_REQUIRE(pthread_join(new, &joinval));
PTHREAD_REQUIRE(pthread_mutex_timedlock(&static_mutex, &ts_lengthy));
printf("1: Thread joined. X was %d. Return value (long) was %ld\n",
global_x, (long)joinval);
ATF_REQUIRE_EQ(global_x, 20000000);
#if defined(__powerpc__)
/* XXX force a timeout in ppc case since an un-triggered race
otherwise looks like a "failure" */
/* We sleep for longer than the timeout to make ATF not
complain about unexpected success */
sleep(41);
#endif
}
static void *
mutex4_threadfunc(void *arg)
{
int *param;
printf("2: Second thread.\n");
param = arg;
printf("2: Locking mutex\n");
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
printf("2: Got mutex. *param = %d\n", *param);
(*param)++;
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
return param;
}
ATF_TC(mutex4);
ATF_TC_HEAD(mutex4, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks mutexes");
}
ATF_TC_BODY(mutex4, tc)
{
int x;
pthread_t new;
pthread_mutexattr_t mattr;
void *joinval;
printf("1: Mutex-test 4\n");
PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr));
PTHREAD_REQUIRE(pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE));
PTHREAD_REQUIRE(pthread_mutex_init(&mutex, &mattr));
PTHREAD_REQUIRE(pthread_mutexattr_destroy(&mattr));
x = 1;
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
PTHREAD_REQUIRE(pthread_create(&new, NULL, mutex4_threadfunc, &x));
printf("1: Before recursively acquiring the mutex.\n");
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
printf("1: Before releasing the mutex once.\n");
sleep(2);
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
printf("1: After releasing the mutex once.\n");
x = 20;
printf("1: Before releasing the mutex twice.\n");
sleep(2);
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
printf("1: After releasing the mutex twice.\n");
PTHREAD_REQUIRE(pthread_join(new, &joinval));
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
printf("1: Thread joined. X was %d. Return value (int) was %d\n",
x, *(int *)joinval);
ATF_REQUIRE_EQ(x, 21);
ATF_REQUIRE_EQ(*(int *)joinval, 21);
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
}
static pthread_mutexattr_t attr5;
static pthread_mutex_t mutex5;
static int min_fifo_prio, max_fifo_prio;
static void *
child_func(void* arg)
{
int res;
printf("child is waiting\n");
res = _sched_protect(-2);
ATF_REQUIRE_EQ_MSG(res, -1, "sched_protect returned %d", res);
ATF_REQUIRE_EQ(errno, ENOENT);
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex5, &ts_lengthy));
printf("child is owning resource\n");
res = _sched_protect(-2);
ATF_REQUIRE_EQ(res, max_fifo_prio);
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex5));
printf("child is done\n");
return 0;
}
ATF_TC(mutex5);
ATF_TC_HEAD(mutex5, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks mutexes for priority setting");
atf_tc_set_md_var(tc, "require.user", "root");
}
ATF_TC_BODY(mutex5, tc)
{
int res;
struct sched_param param;
pthread_t child;
min_fifo_prio = sched_get_priority_min(SCHED_FIFO);
max_fifo_prio = sched_get_priority_max(SCHED_FIFO);
printf("min prio for FIFO = %d\n", min_fifo_prio);
param.sched_priority = min_fifo_prio;
/* = 0 OTHER, 1 FIFO, 2 RR, -1 NONE */
res = sched_setscheduler(getpid(), SCHED_FIFO, &param);
printf("previous policy used = %d\n", res);
res = sched_getscheduler(getpid());
ATF_REQUIRE_EQ_MSG(res, SCHED_FIFO, "sched %d != FIFO %d", res,
SCHED_FIFO);
PTHREAD_REQUIRE(pthread_mutexattr_init(&attr5));
PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&attr5,
PTHREAD_PRIO_PROTECT));
PTHREAD_REQUIRE(pthread_mutexattr_setprioceiling(&attr5,
max_fifo_prio));
PTHREAD_REQUIRE(pthread_mutex_init(&mutex5, &attr5));
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex5, &ts_lengthy));
printf("enter critical section for main\n");
PTHREAD_REQUIRE(pthread_create(&child, NULL, child_func, NULL));
printf("main starts to sleep\n");
sleep(10);
printf("main completes\n");
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex5));
PTHREAD_REQUIRE(pthread_join(child, NULL));
}
static pthread_mutex_t mutex6;
static int start = 0;
static uintmax_t high_cnt = 0, low_cnt = 0, MAX_LOOP = 100000000;
static void *
high_prio(void* arg)
{
struct sched_param param;
int policy;
param.sched_priority = min_fifo_prio + 10;
pthread_t childid = pthread_self();
PTHREAD_REQUIRE(pthread_setschedparam(childid, 1, &param));
PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, &param));
printf("high protect = %d, prio = %d\n",
_sched_protect(-2), param.sched_priority);
ATF_REQUIRE_EQ(policy, 1);
printf("high prio = %d\n", param.sched_priority);
sleep(1);
long tmp = 0;
for (int i = 0; i < 20; i++) {
while (high_cnt < MAX_LOOP) {
tmp += (123456789 % 1234) * (987654321 % 54321);
high_cnt += 1;
}
high_cnt = 0;
sleep(1);
}
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex6, &ts_lengthy));
if (start == 0) start = 2;
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex6));
return 0;
}
static void *
low_prio(void* arg)
{
struct sched_param param;
int policy;
param.sched_priority = min_fifo_prio;
pthread_t childid = pthread_self();
int res = _sched_protect(max_fifo_prio);
ATF_REQUIRE_EQ(res, 0);
PTHREAD_REQUIRE(pthread_setschedparam(childid, 1, &param));
PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, &param));
printf("low protect = %d, prio = %d\n", _sched_protect(-2),
param.sched_priority);
ATF_REQUIRE_EQ(policy, 1);
printf("low prio = %d\n", param.sched_priority);
sleep(1);
long tmp = 0;
for (int i = 0; i < 20; i++) {
while (low_cnt < MAX_LOOP) {
tmp += (123456789 % 1234) * (987654321 % 54321);
low_cnt += 1;
}
low_cnt = 0;
sleep(1);
}
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex6, &ts_lengthy));
if (start == 0)
start = 1;
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex6));
return 0;
}
ATF_TC(mutex6);
ATF_TC_HEAD(mutex6, tc)
{
atf_tc_set_md_var(tc, "descr",
"Checks scheduling for priority ceiling");
atf_tc_set_md_var(tc, "require.user", "root");
}
/*
* 1. main thread sets itself to be a realtime task and launched two tasks,
* one has higher priority and the other has lower priority.
* 2. each child thread(low and high priority thread) sets its scheduler and
* priority.
* 3. each child thread did several rounds of computation, after each round it
* sleep 1 second.
* 4. the child thread with low priority will call _sched_protect to increase
* its protect priority.
* 5. We verify the thread with low priority runs first.
*
* Why does it work? From the main thread, we launched the high
* priority thread first. This gives this thread the benefit of
* starting first. The low priority thread did not call _sched_protect(2).
* The high priority thread should finish the task first. After each
* round of computation, we call sleep, to put the task into the
* sleep queue, and wake up again after the timer expires. This
* gives the scheduler the chance to decide which task to run. So,
* the thread with real high priority will always block the thread
* with real low priority.
*
*/
ATF_TC_BODY(mutex6, tc)
{
struct sched_param param;
int res;
pthread_t high, low;
min_fifo_prio = sched_get_priority_min(SCHED_FIFO);
max_fifo_prio = sched_get_priority_max(SCHED_FIFO);
PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL));
printf("min_fifo_prio = %d, max_fifo_info = %d\n", min_fifo_prio,
max_fifo_prio);
param.sched_priority = min_fifo_prio;
res = sched_setscheduler(getpid(), SCHED_FIFO, &param);
printf("previous policy used = %d\n", res);
res = sched_getscheduler(getpid());
ATF_REQUIRE_EQ(res, 1);
PTHREAD_REQUIRE(pthread_create(&high, NULL, high_prio, NULL));
PTHREAD_REQUIRE(pthread_create(&low, NULL, low_prio, NULL));
sleep(5);
PTHREAD_REQUIRE(pthread_join(low, NULL));
PTHREAD_REQUIRE(pthread_join(high, NULL));
ATF_REQUIRE_EQ(start, 1);
}
ATF_TC(mutexattr1);
ATF_TC_HEAD(mutexattr1, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks mutexattr");
}
ATF_TC_BODY(mutexattr1, tc)
{
pthread_mutexattr_t mattr;
int protocol, target;
PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr));
target = PTHREAD_PRIO_NONE;
PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target));
PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol));
ATF_REQUIRE_EQ(protocol, target);
/*
target = PTHREAD_PRIO_INHERIT;
PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target));
PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol));
ATF_REQUIRE_EQ(protocol, target);
*/
target = PTHREAD_PRIO_PROTECT;
PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target));
PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol));
ATF_REQUIRE_EQ(protocol, target);
}
ATF_TC(mutexattr2);
ATF_TC_HEAD(mutexattr2, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks mutexattr");
}
ATF_TC_BODY(mutexattr2, tc)
{
pthread_mutexattr_t mattr;
PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr));
int max_prio = sched_get_priority_max(SCHED_FIFO);
int min_prio = sched_get_priority_min(SCHED_FIFO);
for (int i = min_prio; i <= max_prio; i++) {
int prioceiling;
PTHREAD_REQUIRE(pthread_mutexattr_setprioceiling(&mattr, i));
PTHREAD_REQUIRE(pthread_mutexattr_getprioceiling(&mattr,
&prioceiling));
ATF_REQUIRE_EQ(i, prioceiling);
}
}
ATF_TC(timedmutex1);
ATF_TC_HEAD(timedmutex1, tc)
{
atf_tc_set_md_var(tc, "descr", "Checks timeout on selflock");
}
ATF_TC_BODY(timedmutex1, tc)
{
printf("Timed mutex-test 1\n");
PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL));
printf("Before acquiring timed-mutex\n");
PTHREAD_REQUIRE(pthread_mutex_lock(&mutex));
printf("Before endavor to reacquire timed-mutex (timeout expected)\n");
PTHREAD_REQUIRE_STATUS(pthread_mutex_timedlock(&mutex, &ts_shortlived),
ETIMEDOUT);
printf("Unlocking timed-mutex\n");
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
}
ATF_TC(timedmutex2);
ATF_TC_HEAD(timedmutex2, tc)
{
atf_tc_set_md_var(tc, "descr",
"Checks timeout on selflock with timedlock");
}
ATF_TC_BODY(timedmutex2, tc)
{
printf("Timed mutex-test 1\n");
PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL));
printf("Before acquiring timed-mutex with timedlock\n");
PTHREAD_REQUIRE(pthread_mutex_timedlock(&mutex, &ts_lengthy));
printf("Before endavor to reacquire timed-mutex (timeout expected)\n");
PTHREAD_REQUIRE_STATUS(pthread_mutex_timedlock(&mutex, &ts_shortlived),
ETIMEDOUT);
printf("Unlocking timed-mutex\n");
PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
}
ATF_TP_ADD_TCS(tp)
{
/* These tests are in sync with t_mutex */
ATF_TP_ADD_TC(tp, mutex1);
ATF_TP_ADD_TC(tp, mutex2);
ATF_TP_ADD_TC(tp, mutex3);
ATF_TP_ADD_TC(tp, mutex4);
ATF_TP_ADD_TC(tp, mutex5);
ATF_TP_ADD_TC(tp, mutex6);
ATF_TP_ADD_TC(tp, mutexattr1);
ATF_TP_ADD_TC(tp, mutexattr2);
/* These ones test timed specific code */
ATF_TP_ADD_TC(tp, timedmutex1);
ATF_TP_ADD_TC(tp, timedmutex2);
return atf_no_error();
}