static void test_mrsp_obtain_release(void)
{
rtems_status_code sc;
rtems_id id;
puts("test MrsP obtain and release");
sc = rtems_semaphore_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
| RTEMS_BINARY_SEMAPHORE,
1,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
assert_prio(2);
sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
assert_prio(1);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
sc = rtems_semaphore_release(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
assert_prio(2);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void Init(rtems_task_argument arg)
{
test_context *ctx = &test_instance;
TEST_BEGIN();
ctx->low = rtems_task_self();
create_task(&ctx->mid, 3);
create_task(&ctx->high, 1);
create_task(&ctx->inversion, 2);
create_sema(&ctx->sem_a);
create_sema(&ctx->sem_b);
obtain_sema(ctx->sem_a);
start_task(ctx->mid, mid_task);
start_task(ctx->high, high_task);
/*
* Here we see that the priority of the high priority task blocked on
* semaphore B propagated to the low priority task owning semaphore A
* on which the owner of semaphore B depends.
*/
assert_prio(ctx->low, 1);
assert_prio(ctx->mid, 1);
assert_prio(ctx->high, 1);
assert_prio(ctx->inversion, 2);
TEST_END();
rtems_test_exit(0);
}
static void test(void)
{
test_context *ctx = &test_instance;
rtems_status_code sc;
ctx->tasks[M] = rtems_task_self();
start_task(ctx, A_1, worker, 1);
start_task(ctx, A_2_0, worker, 2);
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);
obtain(ctx);
request(ctx, A_1, REQ_MTX_OBTAIN);
check_generations(ctx, NONE, NONE);
assert_prio(ctx, M, 1);
release(ctx);
check_generations(ctx, A_1, NONE);
assert_prio(ctx, M, 3);
request(ctx, A_1, REQ_MTX_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);
check_generations(ctx, NONE, NONE);
assert_prio(ctx, M, 1);
release(ctx);
check_generations(ctx, A_1, NONE);
assert_prio(ctx, M, 3);
assert_prio(ctx, A_1, 1);
request(ctx, A_1, REQ_MTX_RELEASE);
check_generations(ctx, A_1, A_2_0);
request(ctx, A_2_0, REQ_MTX_RELEASE);
check_generations(ctx, A_2_0, A_2_1);
request(ctx, A_2_1, REQ_MTX_RELEASE);
check_generations(ctx, A_2_1, NONE);
}
static void inversion_task(rtems_task_argument arg)
{
test_context *ctx = &test_instance;
/*
* Here we see that the priority of the high priority task blocked on
* semaphore B doesn't propagate to the low priority task owning semaphore A
* on which the owner of semaphore B depends.
*/
assert_prio(ctx->low, 3);
assert_prio(ctx->mid, 1);
assert_prio(ctx->high, 1);
assert_prio(ctx->inversion, 2);
TEST_END();
rtems_test_exit(0);
}
