mirror of
https://gitlab.rtems.org/rtems/rtos/rtems.git
synced 2025-11-16 12:34:45 +00:00
sptests/spmutex01: refactor and add deadlock test
This commit is contained in:
Sebastian Huber
committed by
Gedare Bloom
Gedare Bloom
parent
a5c1b2be0c
commit
fc027be4f9
@@ -16,33 +16,65 @@
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <threads.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
#include <rtems.h>
|
||||
#include <rtems/libcsupport.h>
|
||||
|
||||
#ifdef RTEMS_POSIX_API
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
#include "tmacros.h"
|
||||
|
||||
const char rtems_test_name[] = "SPMUTEX 1";
|
||||
|
||||
#define TASK_COUNT 5
|
||||
|
||||
#define MTX_COUNT 3
|
||||
|
||||
typedef enum {
|
||||
REQ_WAKE_UP_MASTER = RTEMS_EVENT_0,
|
||||
REQ_WAKE_UP_HELPER = RTEMS_EVENT_1,
|
||||
REQ_MTX_OBTAIN = RTEMS_EVENT_2,
|
||||
REQ_MTX_RELEASE = RTEMS_EVENT_3
|
||||
REQ_MTX_0_OBTAIN = RTEMS_EVENT_2,
|
||||
REQ_MTX_0_RELEASE = RTEMS_EVENT_3,
|
||||
REQ_MTX_1_OBTAIN = RTEMS_EVENT_4,
|
||||
REQ_MTX_1_RELEASE = RTEMS_EVENT_5,
|
||||
REQ_MTX_2_OBTAIN = RTEMS_EVENT_6,
|
||||
REQ_MTX_2_RELEASE = RTEMS_EVENT_7,
|
||||
REQ_MTX_C11_OBTAIN = RTEMS_EVENT_8,
|
||||
REQ_MTX_C11_RELEASE = RTEMS_EVENT_9,
|
||||
REQ_MTX_POSIX_OBTAIN = RTEMS_EVENT_10,
|
||||
REQ_MTX_POSIX_RELEASE = RTEMS_EVENT_11
|
||||
} request_id;
|
||||
|
||||
typedef enum {
|
||||
M,
|
||||
A_1,
|
||||
A_2_0,
|
||||
A_2_1,
|
||||
M,
|
||||
H,
|
||||
NONE
|
||||
} task_id;
|
||||
|
||||
typedef enum {
|
||||
MTX_0,
|
||||
MTX_1,
|
||||
MTX_2
|
||||
} mutex_id;
|
||||
|
||||
typedef struct {
|
||||
rtems_id mtx;
|
||||
rtems_id mtx[MTX_COUNT];
|
||||
mtx_t mtx_c11;
|
||||
#ifdef RTEMS_POSIX_API
|
||||
pthread_mutex_t mtx_posix;
|
||||
#endif
|
||||
rtems_id tasks[TASK_COUNT];
|
||||
int generation[TASK_COUNT];
|
||||
int expected_generation[TASK_COUNT];
|
||||
jmp_buf deadlock_return_context;
|
||||
} test_context;
|
||||
|
||||
static test_context test_instance;
|
||||
@@ -109,22 +141,79 @@ static void request(test_context *ctx, task_id id, request_id req)
|
||||
sync_with_helper(ctx);
|
||||
}
|
||||
|
||||
static void obtain(test_context *ctx)
|
||||
static void obtain(test_context *ctx, mutex_id id)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
|
||||
sc = rtems_semaphore_obtain(ctx->mtx, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
|
||||
sc = rtems_semaphore_obtain(ctx->mtx[id], RTEMS_WAIT, RTEMS_NO_TIMEOUT);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
static void release(test_context *ctx)
|
||||
static void deadlock_obtain(test_context *ctx, mutex_id id)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
|
||||
sc = rtems_semaphore_release(ctx->mtx);
|
||||
sc = rtems_semaphore_obtain(ctx->mtx[id], RTEMS_WAIT, RTEMS_NO_TIMEOUT);
|
||||
rtems_test_assert(sc == RTEMS_INCORRECT_STATE);
|
||||
}
|
||||
|
||||
static void release(test_context *ctx, mutex_id id)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
|
||||
sc = rtems_semaphore_release(ctx->mtx[id]);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
static void obtain_c11(test_context *ctx)
|
||||
{
|
||||
int status;
|
||||
|
||||
status = mtx_lock(&ctx->mtx_c11);
|
||||
rtems_test_assert(status == thrd_success);
|
||||
}
|
||||
|
||||
static void deadlock_obtain_c11(test_context *ctx)
|
||||
{
|
||||
if (setjmp(ctx->deadlock_return_context) == 0) {
|
||||
(void) mtx_lock(&ctx->mtx_c11);
|
||||
}
|
||||
}
|
||||
|
||||
static void release_c11(test_context *ctx)
|
||||
{
|
||||
int status;
|
||||
|
||||
status = mtx_unlock(&ctx->mtx_c11);
|
||||
rtems_test_assert(status == thrd_success);
|
||||
}
|
||||
|
||||
#ifdef RTEMS_POSIX_API
|
||||
static void obtain_posix(test_context *ctx)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = pthread_mutex_lock(&ctx->mtx_posix);
|
||||
rtems_test_assert(error == 0);
|
||||
}
|
||||
|
||||
static void deadlock_obtain_posix(test_context *ctx)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = pthread_mutex_lock(&ctx->mtx_posix);
|
||||
rtems_test_assert(error == EDEADLK);
|
||||
}
|
||||
|
||||
static void release_posix(test_context *ctx)
|
||||
{
|
||||
int error;
|
||||
|
||||
error = pthread_mutex_unlock(&ctx->mtx_posix);
|
||||
rtems_test_assert(error == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void check_generations(test_context *ctx, task_id a, task_id b)
|
||||
{
|
||||
size_t i;
|
||||
@@ -179,22 +268,65 @@ static void worker(rtems_task_argument arg)
|
||||
while (true) {
|
||||
rtems_event_set events = wait_for_events();
|
||||
|
||||
if ((events & REQ_MTX_OBTAIN) != 0) {
|
||||
obtain(ctx);
|
||||
if ((events & REQ_MTX_0_OBTAIN) != 0) {
|
||||
obtain(ctx, MTX_0);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_RELEASE) != 0) {
|
||||
release(ctx);
|
||||
if ((events & REQ_MTX_0_RELEASE) != 0) {
|
||||
release(ctx, MTX_0);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_1_OBTAIN) != 0) {
|
||||
obtain(ctx, MTX_1);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_1_RELEASE) != 0) {
|
||||
release(ctx, MTX_1);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_2_OBTAIN) != 0) {
|
||||
obtain(ctx, MTX_2);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_2_RELEASE) != 0) {
|
||||
release(ctx, MTX_2);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_C11_OBTAIN) != 0) {
|
||||
obtain_c11(ctx);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_C11_RELEASE) != 0) {
|
||||
release_c11(ctx);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
#ifdef RTEMS_POSIX_API
|
||||
if ((events & REQ_MTX_POSIX_OBTAIN) != 0) {
|
||||
obtain_posix(ctx);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
|
||||
if ((events & REQ_MTX_POSIX_RELEASE) != 0) {
|
||||
release_posix(ctx);
|
||||
++ctx->generation[id];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
static void test(void)
|
||||
static void set_up(test_context *ctx)
|
||||
{
|
||||
test_context *ctx = &test_instance;
|
||||
rtems_status_code sc;
|
||||
int status;
|
||||
size_t i;
|
||||
|
||||
ctx->tasks[M] = rtems_task_self();
|
||||
start_task(ctx, A_1, worker, 1);
|
||||
@@ -202,61 +334,264 @@ static void test(void)
|
||||
start_task(ctx, A_2_1, worker, 2);
|
||||
start_task(ctx, H, helper, 3);
|
||||
|
||||
sc = rtems_semaphore_create(
|
||||
rtems_build_name(' ', 'M', 'T', 'X'),
|
||||
1,
|
||||
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
|
||||
0,
|
||||
&ctx->mtx
|
||||
);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
for (i = 0; i < MTX_COUNT; ++i) {
|
||||
sc = rtems_semaphore_create(
|
||||
rtems_build_name(' ', 'M', 'T', 'X'),
|
||||
1,
|
||||
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
|
||||
0,
|
||||
&ctx->mtx[i]
|
||||
);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
obtain(ctx);
|
||||
request(ctx, A_1, REQ_MTX_OBTAIN);
|
||||
status = mtx_init(&ctx->mtx_c11, mtx_plain);
|
||||
rtems_test_assert(status == thrd_success);
|
||||
|
||||
#ifdef RTEMS_POSIX_API
|
||||
{
|
||||
int error;
|
||||
pthread_mutexattr_t attr;
|
||||
|
||||
error = pthread_mutexattr_init(&attr);
|
||||
rtems_test_assert(error == 0);
|
||||
|
||||
error = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
|
||||
rtems_test_assert(error == 0);
|
||||
|
||||
error = pthread_mutex_init(&ctx->mtx_posix, &attr);
|
||||
rtems_test_assert(error == 0);
|
||||
|
||||
error = pthread_mutexattr_destroy(&attr);
|
||||
rtems_test_assert(error == 0);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static void test_inherit(test_context *ctx)
|
||||
{
|
||||
obtain(ctx, MTX_0);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
assert_prio(ctx, M, 1);
|
||||
release(ctx);
|
||||
release(ctx, MTX_0);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
assert_prio(ctx, M, 3);
|
||||
request(ctx, A_1, REQ_MTX_RELEASE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
}
|
||||
|
||||
obtain(ctx);
|
||||
request(ctx, A_2_0, REQ_MTX_OBTAIN);
|
||||
request(ctx, A_1, REQ_MTX_OBTAIN);
|
||||
request(ctx, A_2_1, REQ_MTX_OBTAIN);
|
||||
static void test_inherit_fifo_for_equal_priority(test_context *ctx)
|
||||
{
|
||||
obtain(ctx, MTX_0);
|
||||
request(ctx, A_2_0, REQ_MTX_0_OBTAIN);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
request(ctx, A_2_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
assert_prio(ctx, M, 1);
|
||||
release(ctx);
|
||||
release(ctx, MTX_0);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
assert_prio(ctx, M, 3);
|
||||
assert_prio(ctx, A_1, 1);
|
||||
request(ctx, A_1, REQ_MTX_RELEASE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, A_2_0);
|
||||
request(ctx, A_2_0, REQ_MTX_RELEASE);
|
||||
request(ctx, A_2_0, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_2_0, A_2_1);
|
||||
request(ctx, A_2_1, REQ_MTX_RELEASE);
|
||||
request(ctx, A_2_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_2_1, NONE);
|
||||
}
|
||||
|
||||
static void test_deadlock_two_classic(test_context *ctx)
|
||||
{
|
||||
obtain(ctx, MTX_0);
|
||||
request(ctx, A_1, REQ_MTX_1_OBTAIN);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
deadlock_obtain(ctx, MTX_1);
|
||||
release(ctx, MTX_0);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_1_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
}
|
||||
|
||||
static void test_deadlock_three_classic(test_context *ctx)
|
||||
{
|
||||
obtain(ctx, MTX_0);
|
||||
request(ctx, A_1, REQ_MTX_1_OBTAIN);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_2_0, REQ_MTX_2_OBTAIN);
|
||||
check_generations(ctx, A_2_0, NONE);
|
||||
request(ctx, A_2_0, REQ_MTX_1_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
deadlock_obtain(ctx, MTX_2);
|
||||
release(ctx, MTX_0);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_1_RELEASE);
|
||||
check_generations(ctx, A_1, A_2_0);
|
||||
request(ctx, A_2_0, REQ_MTX_2_RELEASE);
|
||||
check_generations(ctx, A_2_0, NONE);
|
||||
request(ctx, A_2_0, REQ_MTX_1_RELEASE);
|
||||
check_generations(ctx, A_2_0, NONE);
|
||||
}
|
||||
|
||||
static void test_deadlock_c11_and_classic(test_context *ctx)
|
||||
{
|
||||
obtain_c11(ctx);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_C11_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
deadlock_obtain(ctx, MTX_0);
|
||||
release_c11(ctx);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_C11_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
}
|
||||
|
||||
static void test_deadlock_classic_and_c11(test_context *ctx)
|
||||
{
|
||||
obtain(ctx, MTX_0);
|
||||
request(ctx, A_1, REQ_MTX_C11_OBTAIN);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
deadlock_obtain_c11(ctx);
|
||||
release(ctx, MTX_0);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_C11_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
}
|
||||
|
||||
static void test_deadlock_posix_and_classic(test_context *ctx)
|
||||
{
|
||||
#ifdef RTEMS_POSIX_API
|
||||
obtain_posix(ctx);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_POSIX_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
deadlock_obtain(ctx, MTX_0);
|
||||
release_posix(ctx);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_POSIX_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void test_deadlock_classic_and_posix(test_context *ctx)
|
||||
{
|
||||
#ifdef RTEMS_POSIX_API
|
||||
obtain(ctx, MTX_0);
|
||||
request(ctx, A_1, REQ_MTX_POSIX_OBTAIN);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_OBTAIN);
|
||||
check_generations(ctx, NONE, NONE);
|
||||
deadlock_obtain_posix(ctx);
|
||||
release(ctx, MTX_0);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_0_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
request(ctx, A_1, REQ_MTX_POSIX_RELEASE);
|
||||
check_generations(ctx, A_1, NONE);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void tear_down(test_context *ctx)
|
||||
{
|
||||
rtems_status_code sc;
|
||||
size_t i;
|
||||
|
||||
for (i = 1; i < TASK_COUNT; ++i) {
|
||||
sc = rtems_task_delete(ctx->tasks[i]);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
for (i = 0; i < MTX_COUNT; ++i) {
|
||||
sc = rtems_semaphore_delete(ctx->mtx[i]);
|
||||
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
|
||||
}
|
||||
|
||||
mtx_destroy(&ctx->mtx_c11);
|
||||
|
||||
#ifdef RTEMS_POSIX_API
|
||||
{
|
||||
int error;
|
||||
|
||||
error = pthread_mutex_destroy(&ctx->mtx_posix);
|
||||
rtems_test_assert(error == 0);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static void Init(rtems_task_argument arg)
|
||||
{
|
||||
test_context *ctx = &test_instance;
|
||||
rtems_resource_snapshot snapshot;
|
||||
|
||||
TEST_BEGIN();
|
||||
rtems_resource_snapshot_take(&snapshot);
|
||||
|
||||
test();
|
||||
set_up(ctx);
|
||||
test_inherit(ctx);
|
||||
test_inherit_fifo_for_equal_priority(ctx);
|
||||
test_deadlock_two_classic(ctx);
|
||||
test_deadlock_three_classic(ctx);
|
||||
test_deadlock_c11_and_classic(ctx);
|
||||
test_deadlock_classic_and_c11(ctx);
|
||||
test_deadlock_posix_and_classic(ctx);
|
||||
test_deadlock_classic_and_posix(ctx);
|
||||
tear_down(ctx);
|
||||
|
||||
rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
|
||||
TEST_END();
|
||||
rtems_test_exit(0);
|
||||
}
|
||||
|
||||
static void fatal_extension(
|
||||
rtems_fatal_source source,
|
||||
bool is_internal,
|
||||
rtems_fatal_code error
|
||||
)
|
||||
{
|
||||
|
||||
if (
|
||||
source == INTERNAL_ERROR_CORE
|
||||
&& !is_internal
|
||||
&& error == INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK
|
||||
) {
|
||||
test_context *ctx = &test_instance;
|
||||
|
||||
longjmp(ctx->deadlock_return_context, 1);
|
||||
}
|
||||
}
|
||||
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
|
||||
#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
|
||||
|
||||
#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT
|
||||
|
||||
#define CONFIGURE_MAXIMUM_SEMAPHORES 1
|
||||
#define CONFIGURE_MAXIMUM_SEMAPHORES 3
|
||||
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
|
||||
#ifdef RTEMS_POSIX_API
|
||||
#define CONFIGURE_MAXIMUM_POSIX_MUTEXES 1
|
||||
#endif
|
||||
|
||||
#define CONFIGURE_INITIAL_EXTENSIONS \
|
||||
{ .fatal = fatal_extension }, \
|
||||
RTEMS_TEST_INITIAL_EXTENSION
|
||||
|
||||
#define CONFIGURE_INIT_TASK_PRIORITY 3
|
||||
|
||||
|
||||
@@ -4,6 +4,10 @@ test set name: spmutex01
|
||||
|
||||
directives:
|
||||
|
||||
- mtx_lock()
|
||||
- mtx_unlock()
|
||||
- pthread_mutex_lock()
|
||||
- pthread_mutex_unlock()
|
||||
- rtems_semaphore_create()
|
||||
- rtems_semaphore_obtain()
|
||||
- rtems_semaphore_release()
|
||||
@@ -12,3 +16,4 @@ concepts:
|
||||
|
||||
- Ensure that priority inheritance mechanism works.
|
||||
- Ensure that thread priority queueing discipline works.
|
||||
- Ensure that deadlock detection works in various combinations.
|
||||
|
||||
Reference in New Issue
Block a user