/*
|
* Functional testing of the mutex implementation for Cobalt.
|
*
|
* Copyright (C) Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>,
|
* Marion Deveaud <marion.deveaud@siemens.com>,
|
* Jan Kiszka <jan.kiszka@siemens.com>
|
* Philippe Gerum <rpm@xenomai.org>
|
*
|
* Released under the terms of GPLv2.
|
*/
|
#include <stdio.h>
|
#include <limits.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <errno.h>
|
#include <stdarg.h>
|
#include <unistd.h>
|
#include <signal.h>
|
#include <pthread.h>
|
#include <cobalt/sys/cobalt.h>
|
#include <smokey/smokey.h>
|
|
smokey_test_plugin(posix_mutex,
|
SMOKEY_NOARGS,
|
"Check POSIX mutex services"
|
);
|
|
static const char *reason_str[] = {
|
[SIGDEBUG_UNDEFINED] = "received SIGDEBUG for unknown reason",
|
[SIGDEBUG_MIGRATE_SIGNAL] = "received signal",
|
[SIGDEBUG_MIGRATE_SYSCALL] = "invoked syscall",
|
[SIGDEBUG_MIGRATE_FAULT] = "triggered fault",
|
[SIGDEBUG_MIGRATE_PRIOINV] = "affected by priority inversion",
|
[SIGDEBUG_NOMLOCK] = "process memory not locked",
|
[SIGDEBUG_WATCHDOG] = "watchdog triggered (period too short?)",
|
[SIGDEBUG_LOCK_BREAK] = "scheduler lock break",
|
};
|
|
static void sigdebug(int sig, siginfo_t *si, void *context)
|
{
|
const char fmt[] = "%s, this is unexpected.\n"
|
"(enabling CONFIG_XENO_OPT_DEBUG_TRACE_RELAX may help)\n";
|
unsigned int reason = sigdebug_reason(si);
|
int n __attribute__ ((unused));
|
static char buffer[256];
|
|
if (reason > SIGDEBUG_WATCHDOG)
|
reason = SIGDEBUG_UNDEFINED;
|
|
n = snprintf(buffer, sizeof(buffer), fmt, reason_str[reason]);
|
n = write(STDERR_FILENO, buffer, n);
|
}
|
|
#define THREAD_PRIO_WEAK 0
|
#define THREAD_PRIO_LOW 1
|
#define THREAD_PRIO_MEDIUM 2
|
#define THREAD_PRIO_HIGH 3
|
#define THREAD_PRIO_VERY_HIGH 4
|
|
#define MAX_100_MS 100000000ULL
|
|
struct locker_context {
|
pthread_mutex_t *mutex;
|
struct smokey_barrier *barrier;
|
int lock_acquired;
|
};
|
|
static void sleep_ms(unsigned int ms) /* < 1000 */
|
{
|
struct timespec ts;
|
|
ts.tv_sec = 0;
|
ts.tv_nsec = ms * 1000000;
|
clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
|
}
|
|
static int get_effective_prio(void)
|
{
|
struct cobalt_threadstat stat;
|
int ret;
|
|
ret = cobalt_thread_stat(0, &stat);
|
if (ret)
|
return ret;
|
|
return stat.cprio;
|
}
|
|
static int create_thread(pthread_t *tid, int policy, int prio,
|
void *(*thread)(void *), void *arg)
|
{
|
struct sched_param param;
|
pthread_attr_t thattr;
|
int ret;
|
|
pthread_attr_init(&thattr);
|
param.sched_priority = prio;
|
pthread_attr_setschedpolicy(&thattr, policy);
|
pthread_attr_setschedparam(&thattr, ¶m);
|
pthread_attr_setinheritsched(&thattr, PTHREAD_EXPLICIT_SCHED);
|
|
if (!__T(ret, pthread_create(tid, &thattr, thread, arg)))
|
return ret;
|
|
return 0;
|
}
|
|
static int do_init_mutexattr(pthread_mutexattr_t *mattr, int type, int protocol)
|
{
|
int ret;
|
|
if (!__T(ret, pthread_mutexattr_init(mattr)))
|
return ret;
|
|
if (!__T(ret, pthread_mutexattr_settype(mattr, type)))
|
return ret;
|
|
if (!__T(ret, pthread_mutexattr_setprotocol(mattr, protocol)))
|
return ret;
|
|
if (!__T(ret, pthread_mutexattr_setpshared(mattr, PTHREAD_PROCESS_PRIVATE)))
|
return ret;
|
|
return 0;
|
}
|
|
static int do_init_mutex(pthread_mutex_t *mutex, int type, int protocol)
|
{
|
pthread_mutexattr_t mattr;
|
int ret;
|
|
ret = do_init_mutexattr(&mattr, type, protocol);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_init(mutex, &mattr)))
|
return ret;
|
|
if (!__T(ret, pthread_mutexattr_destroy(&mattr)))
|
return ret;
|
|
return 0;
|
}
|
|
static int do_init_mutex_ceiling(pthread_mutex_t *mutex, int type, int prio)
|
{
|
pthread_mutexattr_t mattr;
|
int ret;
|
|
ret = do_init_mutexattr(&mattr, type, PTHREAD_PRIO_PROTECT);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutexattr_setprioceiling(&mattr, prio)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_init(mutex, &mattr)))
|
return ret;
|
|
if (!__T(ret, pthread_mutexattr_destroy(&mattr)))
|
return ret;
|
|
return 0;
|
}
|
|
static void *mutex_timed_locker(void *arg)
|
{
|
struct locker_context *p = arg;
|
struct timespec now, ts;
|
int ret;
|
|
clock_gettime(CLOCK_REALTIME, &now);
|
/* 5ms (or 50ms in VM) from now */
|
timespec_adds(&ts, &now, smokey_on_vm ? 50000000 : 5000000);
|
|
if (p->barrier)
|
smokey_barrier_release(p->barrier);
|
|
if (__F(ret, pthread_mutex_timedlock(p->mutex, &ts)) &&
|
__Tassert(ret == -ETIMEDOUT))
|
return (void *)1;
|
|
return NULL;
|
}
|
|
static int do_timed_contend(pthread_mutex_t *mutex, int prio)
|
{
|
struct locker_context args = { .barrier = NULL };
|
pthread_t tid;
|
void *status;
|
int ret;
|
|
if (!__T(ret, pthread_mutex_lock(mutex)))
|
return ret;
|
|
args.mutex = mutex;
|
ret = create_thread(&tid, SCHED_FIFO, prio,
|
mutex_timed_locker, &args);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_join(tid, &status)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_unlock(mutex)))
|
return ret;
|
|
if (!__Fassert(status == NULL))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(mutex)))
|
return ret;
|
|
return 0;
|
}
|
|
static void *mutex_locker(void *arg)
|
{
|
struct locker_context *p = arg;
|
int ret;
|
|
if (!__T(ret, pthread_mutex_lock(p->mutex)))
|
return (void *)(long)ret;
|
|
p->lock_acquired = 1;
|
|
if (!__T(ret, pthread_mutex_unlock(p->mutex)))
|
return (void *)(long)ret;
|
|
smokey_barrier_release(p->barrier);
|
|
return NULL;
|
}
|
|
static int do_contend(pthread_mutex_t *mutex, int type)
|
{
|
struct smokey_barrier barrier;
|
struct locker_context args;
|
pthread_t tid;
|
void *status;
|
int ret;
|
|
if (!__T(ret, pthread_mutex_lock(mutex)))
|
return ret;
|
|
if (type == PTHREAD_MUTEX_RECURSIVE) {
|
if (!__T(ret, pthread_mutex_lock(mutex)))
|
return ret;
|
} else if (type == PTHREAD_MUTEX_ERRORCHECK) {
|
if (!__F(ret, pthread_mutex_lock(mutex)) ||
|
!__Tassert(ret == -EDEADLK))
|
return -EINVAL;
|
}
|
|
args.mutex = mutex;
|
smokey_barrier_init(&barrier);
|
args.barrier = &barrier;
|
args.lock_acquired = 0;
|
ret = create_thread(&tid, SCHED_FIFO, THREAD_PRIO_MEDIUM,
|
mutex_locker, &args);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_unlock(mutex)))
|
return ret;
|
|
if (type == PTHREAD_MUTEX_RECURSIVE) {
|
if (!__T(ret, pthread_mutex_unlock(mutex)))
|
return ret;
|
} else if (type == PTHREAD_MUTEX_ERRORCHECK) {
|
if (!__F(ret, pthread_mutex_unlock(mutex)) ||
|
!__Tassert(ret == -EPERM))
|
return -EINVAL;
|
}
|
|
/* Wait until locker runs through. */
|
if (!__T(ret, smokey_barrier_wait(&barrier)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_unlock(mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_destroy(mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_join(tid, &status)))
|
return ret;
|
|
if (!__Tassert(status == NULL))
|
return -EINVAL;
|
|
smokey_barrier_destroy(&barrier);
|
|
return 0;
|
}
|
|
static int do_destroy(pthread_mutex_t *mutex, pthread_mutex_t *invalmutex,
|
int type)
|
{
|
int ret;
|
|
if (!__T(ret, pthread_mutex_destroy(mutex)))
|
return ret;
|
if (!__F(ret, pthread_mutex_destroy(invalmutex)) &&
|
__Tassert(ret == -EINVAL))
|
return -1;
|
return 0;
|
}
|
|
static int static_init_normal_destroy(void)
|
{
|
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
|
pthread_mutex_t invalmutex = PTHREAD_MUTEX_INITIALIZER;
|
|
unsigned int invalmagic = ~0x86860303; // ~COBALT_MUTEX_MAGIC
|
|
memcpy((char *)&invalmutex + sizeof(invalmutex) - sizeof(invalmagic),
|
&invalmagic, sizeof(invalmagic));
|
return do_destroy(&mutex, &invalmutex, PTHREAD_MUTEX_NORMAL);
|
}
|
|
static int static_init_normal_contend(void)
|
{
|
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
return do_contend(&mutex, PTHREAD_MUTEX_NORMAL);
|
}
|
|
static int __dynamic_init_contend(int type)
|
{
|
pthread_mutex_t mutex;
|
int ret;
|
|
ret = do_init_mutex(&mutex, type, PTHREAD_PRIO_NONE);
|
if (ret)
|
return ret;
|
|
return do_contend(&mutex, type);
|
}
|
|
static int dynamic_init_normal_contend(void)
|
{
|
return __dynamic_init_contend(PTHREAD_MUTEX_NORMAL);
|
}
|
|
static int static_init_recursive_destroy(void)
|
{
|
pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
|
pthread_mutex_t invalmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
|
|
unsigned int invalmagic = ~0x86860303; // ~COBALT_MUTEX_MAGIC
|
|
memcpy((char *)&invalmutex + sizeof(invalmutex) - sizeof(invalmagic),
|
&invalmagic, sizeof(invalmagic));
|
return do_destroy(&mutex, &invalmutex, PTHREAD_MUTEX_RECURSIVE);
|
}
|
|
static int static_init_recursive_contend(void)
|
{
|
pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
|
|
return do_contend(&mutex, PTHREAD_MUTEX_RECURSIVE);
|
}
|
|
static int dynamic_init_recursive_contend(void)
|
{
|
return __dynamic_init_contend(PTHREAD_MUTEX_RECURSIVE);
|
}
|
|
static int static_init_errorcheck_destroy(void)
|
{
|
pthread_mutex_t mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
|
pthread_mutex_t invalmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
|
|
unsigned int invalmagic = ~0x86860303; // ~COBALT_MUTEX_MAGIC
|
|
memcpy((char *)&invalmutex + sizeof(invalmutex) - sizeof(invalmagic),
|
&invalmagic, sizeof(invalmagic));
|
return do_destroy(&mutex, &invalmutex, PTHREAD_MUTEX_ERRORCHECK);
|
}
|
|
static int static_init_errorcheck_contend(void)
|
{
|
pthread_mutex_t mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
|
|
return do_contend(&mutex, PTHREAD_MUTEX_ERRORCHECK);
|
}
|
|
static int dynamic_init_errorcheck_contend(void)
|
{
|
return __dynamic_init_contend(PTHREAD_MUTEX_ERRORCHECK);
|
}
|
|
static int timed_contend(void)
|
{
|
pthread_mutex_t mutex;
|
int ret;
|
|
ret = do_init_mutex(&mutex, PTHREAD_MUTEX_NORMAL,
|
PTHREAD_PRIO_INHERIT);
|
if (ret)
|
return ret;
|
|
return do_timed_contend(&mutex, THREAD_PRIO_MEDIUM);
|
}
|
|
static int weak_mode_switch(void)
|
{
|
struct sched_param old_param, param = { .sched_priority = 0 };
|
int old_policy, ret, mode;
|
pthread_mutex_t mutex;
|
|
ret = do_init_mutex(&mutex, PTHREAD_MUTEX_NORMAL,
|
PTHREAD_PRIO_INHERIT);
|
if (ret)
|
return ret;
|
|
/* Save old schedparams, then switch to weak mode. */
|
|
if (!__T(ret, pthread_getschedparam(pthread_self(),
|
&old_policy, &old_param)))
|
return ret;
|
|
/* Assume we are running SCHED_FIFO. */
|
|
mode = cobalt_thread_mode();
|
if (!__Fassert(mode & XNWEAK))
|
return -EINVAL;
|
|
/* Enter SCHED_WEAK scheduling. */
|
|
if (!__T(ret, pthread_setschedparam(pthread_self(),
|
SCHED_OTHER, ¶m)))
|
return ret;
|
|
mode = cobalt_thread_mode();
|
if (!__Tassert((mode & (XNWEAK|XNRELAX)) == (XNWEAK|XNRELAX)))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
/*
|
* Holding a mutex should have switched us out of relaxed
|
* mode despite being assigned to the SCHED_WEAK class.
|
*/
|
mode = cobalt_thread_mode();
|
if (!__Tassert((mode & (XNWEAK|XNRELAX)) == XNWEAK))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
/* Dropped it, we should have relaxed in the same move. */
|
|
mode = cobalt_thread_mode();
|
if (!__Tassert((mode & (XNWEAK|XNRELAX)) == (XNWEAK|XNRELAX)))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
/* Leaving the SCHED_WEAK class. */
|
|
if (!__T(ret, pthread_setschedparam(pthread_self(),
|
old_policy, &old_param)))
|
return ret;
|
|
mode = cobalt_thread_mode();
|
if (!__Fassert(mode & XNWEAK))
|
return -EINVAL;
|
|
return 0;
|
}
|
|
static int do_pi_contend(int prio)
|
{
|
struct smokey_barrier barrier;
|
struct locker_context args;
|
pthread_mutex_t mutex;
|
pthread_t tid;
|
void *status;
|
int ret;
|
|
ret = do_init_mutex(&mutex, PTHREAD_MUTEX_NORMAL,
|
PTHREAD_PRIO_INHERIT);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
args.mutex = &mutex;
|
smokey_barrier_init(&barrier);
|
args.barrier = &barrier;
|
ret = create_thread(&tid, SCHED_FIFO, prio,
|
mutex_timed_locker, &args);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, smokey_barrier_wait(&barrier)))
|
return ret;
|
|
/*
|
* Back while mutex_timed_locker is waiting. We should have
|
* been boosted by now.
|
*/
|
if (!__Tassert(get_effective_prio() == prio))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_join(tid, &status)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (!__Fassert(status == NULL))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
smokey_barrier_destroy(&barrier);
|
|
return 0;
|
}
|
|
static int pi_contend(void)
|
{
|
return do_pi_contend(THREAD_PRIO_HIGH);
|
}
|
|
static void *mutex_locker_steal(void *arg)
|
{
|
struct locker_context *p = arg;
|
int ret;
|
|
smokey_barrier_release(p->barrier);
|
|
if (!__T(ret, pthread_mutex_lock(p->mutex)))
|
return (void *)(long)ret;
|
|
p->lock_acquired = 1;
|
|
if (!__T(ret, pthread_mutex_unlock(p->mutex)))
|
return (void *)(long)ret;
|
|
return NULL;
|
}
|
|
static int do_steal(int may_steal)
|
{
|
struct smokey_barrier barrier;
|
struct locker_context args;
|
pthread_mutex_t mutex;
|
pthread_t tid;
|
void *status;
|
int ret;
|
|
ret = do_init_mutex(&mutex, PTHREAD_MUTEX_NORMAL,
|
PTHREAD_PRIO_NONE);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
args.mutex = &mutex;
|
smokey_barrier_init(&barrier);
|
args.barrier = &barrier;
|
args.lock_acquired = 0;
|
ret = create_thread(&tid, SCHED_FIFO, THREAD_PRIO_LOW,
|
mutex_locker_steal, &args);
|
if (ret)
|
return ret;
|
|
/* Make sure the locker thread emerges... */
|
if (!__T(ret, smokey_barrier_wait(&barrier)))
|
return ret;
|
|
/* ...and blocks waiting on the mutex. */
|
sleep_ms(1);
|
|
/*
|
* Back while mutex_locker should be blocking.
|
*
|
* If stealing is exercised, unlock then relock immediately:
|
* we should have kept the ownership of the mutex and the
|
* locker thread should not have grabbed it so far, because of
|
* our higher priority.
|
*
|
* If stealing should not happen, unlock, wait a moment then
|
* observe whether the locker thread was able to grab it as
|
* expected.
|
*
|
* CAUTION: don't use pthread_mutex_trylock() to re-grab the
|
* mutex, this is not going to do what you want, since there
|
* is no stealing from userland, so using a fast op which
|
* never enters the kernel won't help.
|
*/
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (may_steal) {
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
if (!__Fassert(args.lock_acquired))
|
return -EINVAL;
|
} else {
|
sleep_ms(1);
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
if (!__Tassert(args.lock_acquired))
|
return -EINVAL;
|
}
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_join(tid, &status)))
|
return ret;
|
|
if (!__Tassert(status == NULL))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
smokey_barrier_destroy(&barrier);
|
|
return 0;
|
}
|
|
static int steal(void)
|
{
|
return do_steal(1);
|
}
|
|
static int no_steal(void)
|
{
|
return do_steal(0);
|
}
|
|
/*
|
* NOTE: Cobalt implements a lazy enforcement scheme for priority
|
* protection of threads running in primary mode, which only registers
|
* a pending boost at locking time, committing it eventually when/if
|
* the owner thread schedules away while holding it. Entering a short
|
* sleep (in primary mode) right after a mutex is grabbed makes sure
|
* the boost is actually applied.
|
*/
|
static int protect_raise(void)
|
{
|
pthread_mutex_t mutex;
|
int ret;
|
|
ret = do_init_mutex_ceiling(&mutex, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_HIGH);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
/* We should have been given a MEDIUM -> HIGH boost. */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_MEDIUM))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
return 0;
|
}
|
|
static int protect_lower(void)
|
{
|
pthread_mutex_t mutex;
|
int ret;
|
|
ret = do_init_mutex_ceiling(&mutex, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_LOW);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
/* No boost should be applied. */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_MEDIUM))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_MEDIUM))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
return 0;
|
}
|
|
static int protect_weak(void)
|
{
|
struct sched_param old_param, weak_param;
|
pthread_mutex_t mutex;
|
int ret, old_policy;
|
|
if (!__T(ret, pthread_getschedparam(pthread_self(),
|
&old_policy, &old_param)))
|
return ret;
|
|
/*
|
* Switch to the SCHED_WEAK class if present. THREAD_PRIO_WEAK
|
* (0) is used to make this work even without SCHED_WEAK
|
* support.
|
*/
|
weak_param.sched_priority = THREAD_PRIO_WEAK;
|
if (!__T(ret, pthread_setschedparam(pthread_self(),
|
SCHED_WEAK, &weak_param)))
|
return ret;
|
|
ret = do_init_mutex_ceiling(&mutex, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_HIGH);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
/* We should have been sent to SCHED_FIFO, THREAD_PRIO_HIGH. */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
/* Back to SCHED_WEAK, THREAD_PRIO_WEAK. */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_WEAK))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_setschedparam(pthread_self(),
|
old_policy, &old_param)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
return 0;
|
}
|
|
static int protect_nesting_protect(void)
|
{
|
pthread_mutex_t mutex_high, mutex_very_high;
|
int ret;
|
|
ret = do_init_mutex_ceiling(&mutex_high, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_HIGH);
|
if (ret)
|
return ret;
|
|
ret = do_init_mutex_ceiling(&mutex_very_high, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_VERY_HIGH);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex_high)))
|
return ret;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex_very_high)))
|
return ret;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_VERY_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex_very_high)))
|
return ret;
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex_high)))
|
return ret;
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_MEDIUM))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex_high)) ||
|
!__T(ret, pthread_mutex_destroy(&mutex_very_high)))
|
return ret;
|
|
return 0;
|
}
|
|
static int protect_nesting_pi(void)
|
{
|
pthread_mutex_t mutex_pp;
|
int ret;
|
|
ret = do_init_mutex_ceiling(&mutex_pp, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_HIGH);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex_pp)))
|
return ret;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
/* PP ceiling: MEDIUM -> HIGH */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
/* PI boost expected: HIGH -> VERY_HIGH, then back to HIGH */
|
ret = do_pi_contend(THREAD_PRIO_VERY_HIGH);
|
if (ret)
|
return ret;
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex_pp)))
|
return ret;
|
|
/* PP boost just dropped: HIGH -> MEDIUM. */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_MEDIUM))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex_pp)))
|
return ret;
|
|
return 0;
|
}
|
|
static int protect_dynamic(void)
|
{
|
pthread_mutex_t mutex;
|
int ret, old_ceiling;
|
|
ret = do_init_mutex_ceiling(&mutex, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_HIGH);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_setprioceiling(&mutex,
|
THREAD_PRIO_VERY_HIGH, &old_ceiling)))
|
return ret;
|
|
if (!__Tassert(old_ceiling == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
/* We should have been given a HIGH -> VERY_HIGH boost. */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_VERY_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
/* Drop the boost: VERY_HIGH -> MEDIUM. */
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_MEDIUM))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_getprioceiling(&mutex, &old_ceiling)))
|
return ret;
|
|
if (!__Tassert(old_ceiling == THREAD_PRIO_VERY_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
return 0;
|
}
|
|
static int protect_trylock(void)
|
{
|
pthread_mutex_t mutex;
|
int ret;
|
|
ret = do_init_mutex_ceiling(&mutex, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_HIGH);
|
if (ret)
|
return ret;
|
|
/* make sure we are primary to take the fast-path */
|
sleep_ms(1);
|
|
if (!__T(ret, pthread_mutex_trylock(&mutex)))
|
return ret;
|
|
if (!__Tassert(pthread_mutex_trylock(&mutex) == EBUSY))
|
return -EINVAL;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
/* force to secondary to take the slow-path */
|
__real_usleep(1);
|
|
if (!__T(ret, pthread_mutex_trylock(&mutex)))
|
return ret;
|
|
/* force to secondary to take the slow-path */
|
if (!__Tassert(pthread_mutex_trylock(&mutex) == EBUSY))
|
return -EINVAL;
|
|
sleep_ms(1); /* Commit the pending PP request. */
|
|
if (!__Tassert(get_effective_prio() == THREAD_PRIO_HIGH))
|
return -EINVAL;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
return 0;
|
}
|
|
static int protect_handover(void)
|
{
|
struct smokey_barrier barrier;
|
struct locker_context args;
|
pthread_mutex_t mutex;
|
pthread_t tid;
|
int ret;
|
|
ret = do_init_mutex_ceiling(&mutex, PTHREAD_MUTEX_NORMAL,
|
THREAD_PRIO_HIGH);
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
args.mutex = &mutex;
|
smokey_barrier_init(&barrier);
|
args.barrier = &barrier;
|
args.lock_acquired = 0;
|
ret = create_thread(&tid, SCHED_FIFO, THREAD_PRIO_LOW,
|
mutex_locker, &args);
|
if (ret)
|
return ret;
|
|
sleep_ms(1); /* Wait for the locker to contend on the mutex. */
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
/* Make sure the locker thread released the lock again. */
|
if (!__T(ret, smokey_barrier_wait(&barrier)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_lock(&mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
smokey_barrier_destroy(&barrier);
|
|
return 0;
|
}
|
|
static void *mutex_timed_locker_inv_timeout(void *arg)
|
{
|
struct locker_context *p = arg;
|
int ret;
|
|
if (__F(ret, pthread_mutex_timedlock(p->mutex, (void *) 0xdeadbeef)) &&
|
__Tassert(ret == -EFAULT))
|
return (void *)1;
|
|
return NULL;
|
}
|
|
static int check_timedlock_abstime_validation(void)
|
{
|
struct locker_context args;
|
pthread_mutex_t mutex;
|
pthread_t tid;
|
void *status;
|
int ret;
|
|
if (!__T(ret, pthread_mutex_init(&mutex, NULL)))
|
return ret;
|
|
/*
|
* We don't own the mutex yet, so no need to validate the timeout as
|
* the mutex can be locked immediately.
|
*
|
* The second parameter of phtread_mutex_timedlock() is flagged as
|
* __nonnull so we take an invalid address instead of NULL.
|
*/
|
if (!__T(ret, pthread_mutex_timedlock(&mutex, (void *) 0xdeadbeef)))
|
return ret;
|
|
/*
|
* Create a second thread which will have to wait and therefore will
|
* validate the (invalid) timeout
|
*/
|
args.mutex = &mutex;
|
ret = create_thread(&tid, SCHED_FIFO, THREAD_PRIO_LOW,
|
mutex_timed_locker_inv_timeout, &args);
|
|
if (ret)
|
return ret;
|
|
if (!__T(ret, pthread_join(tid, &status)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_unlock(&mutex)))
|
return ret;
|
|
if (!__T(ret, pthread_mutex_destroy(&mutex)))
|
return ret;
|
|
if (!__Fassert(status == NULL))
|
return -EINVAL;
|
|
return 0;
|
}
|
|
/* Detect obviously wrong execution times. */
|
static int check_time_limit(const struct timespec *start,
|
xnticks_t limit_ns)
|
{
|
struct timespec stop, delta;
|
|
clock_gettime(CLOCK_MONOTONIC, &stop);
|
timespec_sub(&delta, &stop, start);
|
|
return timespec_scalar(&delta) <= limit_ns;
|
}
|
|
#define do_test(__fn, __limit_ns) \
|
do { \
|
struct timespec __start; \
|
int __ret; \
|
smokey_trace(".. " __stringify(__fn)); \
|
clock_gettime(CLOCK_MONOTONIC, &__start); \
|
__ret = __fn(); \
|
if (__ret) \
|
return __ret; \
|
if (!__Tassert(check_time_limit(&__start, __limit_ns))) \
|
return -ETIMEDOUT; \
|
} while (0)
|
|
static int run_posix_mutex(struct smokey_test *t, int argc, char *const argv[])
|
{
|
struct sched_param param;
|
struct sigaction sa;
|
int ret;
|
|
sigemptyset(&sa.sa_mask);
|
sa.sa_sigaction = sigdebug;
|
sa.sa_flags = SA_SIGINFO;
|
sigaction(SIGDEBUG, &sa, NULL);
|
|
param.sched_priority = THREAD_PRIO_MEDIUM;
|
if (!__T(ret, pthread_setschedparam(pthread_self(),
|
SCHED_FIFO, ¶m)))
|
return ret;
|
|
do_test(static_init_normal_destroy, MAX_100_MS);
|
do_test(static_init_normal_contend, MAX_100_MS);
|
do_test(dynamic_init_normal_contend, MAX_100_MS);
|
do_test(static_init_recursive_destroy, MAX_100_MS);
|
do_test(static_init_recursive_contend, MAX_100_MS);
|
do_test(dynamic_init_recursive_contend, MAX_100_MS);
|
do_test(static_init_errorcheck_destroy, MAX_100_MS);
|
do_test(static_init_errorcheck_contend, MAX_100_MS);
|
do_test(dynamic_init_errorcheck_contend, MAX_100_MS);
|
do_test(timed_contend, MAX_100_MS);
|
do_test(weak_mode_switch, MAX_100_MS);
|
do_test(pi_contend, MAX_100_MS);
|
do_test(steal, MAX_100_MS);
|
do_test(no_steal, MAX_100_MS);
|
do_test(protect_raise, MAX_100_MS);
|
do_test(protect_lower, MAX_100_MS);
|
do_test(protect_nesting_protect, MAX_100_MS);
|
do_test(protect_nesting_pi, MAX_100_MS);
|
do_test(protect_weak, MAX_100_MS);
|
do_test(protect_dynamic, MAX_100_MS);
|
do_test(protect_trylock, MAX_100_MS);
|
do_test(protect_handover, MAX_100_MS);
|
do_test(check_timedlock_abstime_validation, MAX_100_MS);
|
|
return 0;
|
}
|
