Changeset 95d5a0a9 in rtems


Ignore:
Timestamp:
Dec 20, 2017, 6:17:00 PM (3 years ago)
Author:
Gedare Bloom <gedare@…>
Branches:
4.10
Children:
83e6cefa
Parents:
f9126f6
git-author:
Gedare Bloom <gedare@…> (12/20/17 18:17:00)
git-committer:
Gedare Bloom <gedare@…> (03/23/18 15:33:59)
Message:

sptests/spmutex01: strip out deadlock, c11, posix

Location:
testsuites/sptests/spmutex01
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • testsuites/sptests/spmutex01/init.c

    rf9126f6 r95d5a0a9  
    1717#endif
    1818
    19 #include <threads.h>
    20 #include <setjmp.h>
    21 
    2219#include <rtems.h>
    2320#include <rtems/libcsupport.h>
    24 
    25 #ifdef RTEMS_POSIX_API
    26 #include <errno.h>
    27 #include <pthread.h>
    28 #endif
    2921
    3022#include "tmacros.h"
     
    4638  REQ_MTX_2_OBTAIN = RTEMS_EVENT_7,
    4739  REQ_MTX_2_RELEASE = RTEMS_EVENT_8,
    48   REQ_MTX_C11_OBTAIN = RTEMS_EVENT_9,
    49   REQ_MTX_C11_RELEASE = RTEMS_EVENT_10,
    50   REQ_MTX_POSIX_OBTAIN = RTEMS_EVENT_11,
    51   REQ_MTX_POSIX_RELEASE = RTEMS_EVENT_12
    5240} request_id;
    5341
     
    6957typedef struct {
    7058  rtems_id mtx[MTX_COUNT];
    71   mtx_t mtx_c11;
    72 #ifdef RTEMS_POSIX_API
    73   pthread_mutex_t mtx_posix;
    74 #endif
    7559  rtems_id tasks[TASK_COUNT];
    7660  int generation[TASK_COUNT];
    7761  int expected_generation[TASK_COUNT];
    78   jmp_buf deadlock_return_context;
    7962} test_context;
    8063
     
    167150}
    168151
    169 static void deadlock_obtain(test_context *ctx, mutex_id id)
    170 {
    171   rtems_status_code sc;
    172 
    173   sc = rtems_semaphore_obtain(ctx->mtx[id], RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    174   rtems_test_assert(sc == RTEMS_INCORRECT_STATE);
    175 }
    176 
    177152static void release(test_context *ctx, mutex_id id)
    178153{
     
    182157  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
    183158}
    184 
    185 static void obtain_c11(test_context *ctx)
    186 {
    187   int status;
    188 
    189   status = mtx_lock(&ctx->mtx_c11);
    190   rtems_test_assert(status == thrd_success);
    191 }
    192 
    193 static void deadlock_obtain_c11(test_context *ctx)
    194 {
    195   if (setjmp(ctx->deadlock_return_context) == 0) {
    196     (void) mtx_lock(&ctx->mtx_c11);
    197   }
    198 }
    199 
    200 static void release_c11(test_context *ctx)
    201 {
    202   int status;
    203 
    204   status = mtx_unlock(&ctx->mtx_c11);
    205   rtems_test_assert(status == thrd_success);
    206 }
    207 
    208 #ifdef RTEMS_POSIX_API
    209 static void obtain_posix(test_context *ctx)
    210 {
    211   int error;
    212 
    213   error = pthread_mutex_lock(&ctx->mtx_posix);
    214   rtems_test_assert(error == 0);
    215 }
    216 
    217 static void deadlock_obtain_posix(test_context *ctx)
    218 {
    219   int error;
    220 
    221   error = pthread_mutex_lock(&ctx->mtx_posix);
    222   rtems_test_assert(error == EDEADLK);
    223 }
    224 
    225 static void release_posix(test_context *ctx)
    226 {
    227   int error;
    228 
    229   error = pthread_mutex_unlock(&ctx->mtx_posix);
    230   rtems_test_assert(error == 0);
    231 }
    232 #endif
    233159
    234160static void check_generations(test_context *ctx, task_id a, task_id b)
     
    336262      ++ctx->generation[id];
    337263    }
    338 
    339     if ((events & REQ_MTX_C11_OBTAIN) != 0) {
    340       obtain_c11(ctx);
    341       ++ctx->generation[id];
    342     }
    343 
    344     if ((events & REQ_MTX_C11_RELEASE) != 0) {
    345       release_c11(ctx);
    346       ++ctx->generation[id];
    347     }
    348 
    349 #ifdef RTEMS_POSIX_API
    350     if ((events & REQ_MTX_POSIX_OBTAIN) != 0) {
    351       obtain_posix(ctx);
    352       ++ctx->generation[id];
    353     }
    354 
    355     if ((events & REQ_MTX_POSIX_RELEASE) != 0) {
    356       release_posix(ctx);
    357       ++ctx->generation[id];
    358     }
    359 #endif
    360264  }
    361265}
     
    383287    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
    384288  }
    385 
    386   status = mtx_init(&ctx->mtx_c11, mtx_plain);
    387   rtems_test_assert(status == thrd_success);
    388 
    389 #ifdef RTEMS_POSIX_API
    390   {
    391     int error;
    392     pthread_mutexattr_t attr;
    393 
    394     error = pthread_mutexattr_init(&attr);
    395     rtems_test_assert(error == 0);
    396 
    397     error = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
    398     rtems_test_assert(error == 0);
    399 
    400     error = pthread_mutex_init(&ctx->mtx_posix, &attr);
    401     rtems_test_assert(error == 0);
    402 
    403     error = pthread_mutexattr_destroy(&attr);
    404     rtems_test_assert(error == 0);
    405   }
    406 #endif
    407289}
    408290
     
    526408}
    527409
    528 static void test_deadlock_two_classic(test_context *ctx)
    529 {
    530   obtain(ctx, MTX_0);
    531   request(ctx, A_1, REQ_MTX_1_OBTAIN);
    532   check_generations(ctx, A_1, NONE);
    533   request(ctx, A_1, REQ_MTX_0_OBTAIN);
    534   check_generations(ctx, NONE, NONE);
    535   deadlock_obtain(ctx, MTX_1);
    536   release(ctx, MTX_0);
    537   check_generations(ctx, A_1, NONE);
    538   request(ctx, A_1, REQ_MTX_0_RELEASE);
    539   check_generations(ctx, A_1, NONE);
    540   request(ctx, A_1, REQ_MTX_1_RELEASE);
    541   check_generations(ctx, A_1, NONE);
    542 }
    543 
    544 static void test_deadlock_three_classic(test_context *ctx)
    545 {
    546   obtain(ctx, MTX_0);
    547   request(ctx, A_1, REQ_MTX_1_OBTAIN);
    548   check_generations(ctx, A_1, NONE);
    549   request(ctx, A_2_0, REQ_MTX_2_OBTAIN);
    550   check_generations(ctx, A_2_0, NONE);
    551   request(ctx, A_2_0, REQ_MTX_1_OBTAIN);
    552   check_generations(ctx, NONE, NONE);
    553   request(ctx, A_1, REQ_MTX_0_OBTAIN);
    554   check_generations(ctx, NONE, NONE);
    555   deadlock_obtain(ctx, MTX_2);
    556   release(ctx, MTX_0);
    557   check_generations(ctx, A_1, NONE);
    558   request(ctx, A_1, REQ_MTX_0_RELEASE);
    559   check_generations(ctx, A_1, NONE);
    560   request(ctx, A_1, REQ_MTX_1_RELEASE);
    561   check_generations(ctx, A_1, A_2_0);
    562   request(ctx, A_2_0, REQ_MTX_2_RELEASE);
    563   check_generations(ctx, A_2_0, NONE);
    564   request(ctx, A_2_0, REQ_MTX_1_RELEASE);
    565   check_generations(ctx, A_2_0, NONE);
    566 }
    567 
    568 static void test_deadlock_c11_and_classic(test_context *ctx)
    569 {
    570   obtain_c11(ctx);
    571   request(ctx, A_1, REQ_MTX_0_OBTAIN);
    572   check_generations(ctx, A_1, NONE);
    573   request(ctx, A_1, REQ_MTX_C11_OBTAIN);
    574   check_generations(ctx, NONE, NONE);
    575   deadlock_obtain(ctx, MTX_0);
    576   release_c11(ctx);
    577   check_generations(ctx, A_1, NONE);
    578   request(ctx, A_1, REQ_MTX_C11_RELEASE);
    579   check_generations(ctx, A_1, NONE);
    580   request(ctx, A_1, REQ_MTX_0_RELEASE);
    581   check_generations(ctx, A_1, NONE);
    582 }
    583 
    584 static void test_deadlock_classic_and_c11(test_context *ctx)
    585 {
    586   obtain(ctx, MTX_0);
    587   request(ctx, A_1, REQ_MTX_C11_OBTAIN);
    588   check_generations(ctx, A_1, NONE);
    589   request(ctx, A_1, REQ_MTX_0_OBTAIN);
    590   check_generations(ctx, NONE, NONE);
    591   deadlock_obtain_c11(ctx);
    592   release(ctx, MTX_0);
    593   check_generations(ctx, A_1, NONE);
    594   request(ctx, A_1, REQ_MTX_0_RELEASE);
    595   check_generations(ctx, A_1, NONE);
    596   request(ctx, A_1, REQ_MTX_C11_RELEASE);
    597   check_generations(ctx, A_1, NONE);
    598 }
    599 
    600 static void test_deadlock_posix_and_classic(test_context *ctx)
    601 {
    602 #ifdef RTEMS_POSIX_API
    603   obtain_posix(ctx);
    604   request(ctx, A_1, REQ_MTX_0_OBTAIN);
    605   check_generations(ctx, A_1, NONE);
    606   request(ctx, A_1, REQ_MTX_POSIX_OBTAIN);
    607   check_generations(ctx, NONE, NONE);
    608   deadlock_obtain(ctx, MTX_0);
    609   release_posix(ctx);
    610   check_generations(ctx, A_1, NONE);
    611   request(ctx, A_1, REQ_MTX_POSIX_RELEASE);
    612   check_generations(ctx, A_1, NONE);
    613   request(ctx, A_1, REQ_MTX_0_RELEASE);
    614   check_generations(ctx, A_1, NONE);
    615 #endif
    616 }
    617 
    618 static void test_deadlock_classic_and_posix(test_context *ctx)
    619 {
    620 #ifdef RTEMS_POSIX_API
    621   obtain(ctx, MTX_0);
    622   request(ctx, A_1, REQ_MTX_POSIX_OBTAIN);
    623   check_generations(ctx, A_1, NONE);
    624   request(ctx, A_1, REQ_MTX_0_OBTAIN);
    625   check_generations(ctx, NONE, NONE);
    626   deadlock_obtain_posix(ctx);
    627   release(ctx, MTX_0);
    628   check_generations(ctx, A_1, NONE);
    629   request(ctx, A_1, REQ_MTX_0_RELEASE);
    630   check_generations(ctx, A_1, NONE);
    631   request(ctx, A_1, REQ_MTX_POSIX_RELEASE);
    632   check_generations(ctx, A_1, NONE);
    633 #endif
    634 }
    635 
    636410static void tear_down(test_context *ctx)
    637411{
     
    648422    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
    649423  }
    650 
    651   mtx_destroy(&ctx->mtx_c11);
    652 
    653 #ifdef RTEMS_POSIX_API
    654   {
    655     int error;
    656 
    657     error = pthread_mutex_destroy(&ctx->mtx_posix);
    658     rtems_test_assert(error == 0);
    659   }
    660 #endif
    661424}
    662425
     
    675438  test_inherit_nested_vertical_timeout(ctx);
    676439  test_inherit_nested_horizontal(ctx);
    677   test_deadlock_two_classic(ctx);
    678   test_deadlock_three_classic(ctx);
    679   test_deadlock_c11_and_classic(ctx);
    680   test_deadlock_classic_and_c11(ctx);
    681   test_deadlock_posix_and_classic(ctx);
    682   test_deadlock_classic_and_posix(ctx);
    683440  tear_down(ctx);
    684441
     
    688445}
    689446
    690 static void fatal_extension(
    691   rtems_fatal_source source,
    692   bool is_internal,
    693   rtems_fatal_code error
    694 )
    695 {
    696 
    697   if (
    698     source == INTERNAL_ERROR_CORE
    699       && !is_internal
    700       && error == INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK
    701   ) {
    702     test_context *ctx = &test_instance;
    703 
    704     longjmp(ctx->deadlock_return_context, 1);
    705   }
    706 }
    707 
    708447#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
    709448#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
     
    717456#endif
    718457
    719 #define CONFIGURE_INITIAL_EXTENSIONS \
    720   { .fatal = fatal_extension }, \
    721   RTEMS_TEST_INITIAL_EXTENSION
     458#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
    722459
    723460#define CONFIGURE_INIT_TASK_PRIORITY 3
Note: See TracChangeset for help on using the changeset viewer.