Changeset 9553e7a6 in rtems


Ignore:
Timestamp:
May 26, 2014, 2:02:58 PM (5 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, master
Children:
1ee0d5f
Parents:
3045738
git-author:
Sebastian Huber <sebastian.huber@…> (05/26/14 14:02:58)
git-committer:
Sebastian Huber <sebastian.huber@…> (06/03/14 06:15:16)
Message:

score: Use Resource Handler for MrsP semaphores

This enables proper resource dependency tracking and as a side-effect
deadlock detection.

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • cpukit/score/include/rtems/score/mrsp.h

    r3045738 r9553e7a6  
    6464  MRSP_RESOUCE_IN_USE = 12,
    6565  MRSP_UNSATISFIED = 13,
     66  MRSP_INCORRECT_STATE = 14,
    6667  MRSP_INVALID_PRIORITY = 19,
    6768  MRSP_NOT_OWNER_OF_RESOURCE = 23,
     
    103104typedef struct {
    104105  /**
    105    * @brief The owner of the MRSP resource.
    106    *
    107    * In case this field is @c NULL, then this MRSP resource has currently no
    108    * owner.
     106   * @brief Basic resource control.
    109107   */
    110   Thread_Control *owner;
     108  Resource_Control Resource;
    111109
    112110  /**
     
    116114   */
    117115  Chain_Control Rivals;
     116
     117  /**
     118   * @brief The initial priority of the owner before it was elevated to the
     119   * ceiling priority.
     120   */
     121  Priority_Control initial_priority_of_owner;
    118122
    119123  /**
  • cpukit/score/include/rtems/score/mrspimpl.h

    r3045738 r9553e7a6  
    2222#include <rtems/score/assert.h>
    2323#include <rtems/score/chainimpl.h>
     24#include <rtems/score/resourceimpl.h>
    2425#include <rtems/score/schedulerimpl.h>
    2526#include <rtems/score/watchdogimpl.h>
     
    4243#define MRSP_RIVAL_STATE_TIMEOUT 0x2U
    4344
     45RTEMS_INLINE_ROUTINE bool _MRSP_Set_root_visitor(
     46  Resource_Node *node,
     47  void *arg
     48)
     49{
     50  _Resource_Node_set_root( node, arg );
     51
     52  return false;
     53}
     54
     55RTEMS_INLINE_ROUTINE void _MRSP_Set_root(
     56  Resource_Node *top,
     57  Resource_Node *root
     58)
     59{
     60  _Resource_Node_set_root( top, root );
     61  _Resource_Iterate( top, _MRSP_Set_root_visitor, root );
     62}
     63
     64RTEMS_INLINE_ROUTINE void _MRSP_Elevate_priority(
     65  MRSP_Control     *mrsp,
     66  Thread_Control   *new_owner,
     67  Priority_Control  ceiling_priority
     68)
     69{
     70  _Thread_Change_priority( new_owner, ceiling_priority, false );
     71}
     72
     73RTEMS_INLINE_ROUTINE void _MRSP_Restore_priority(
     74  const MRSP_Control *mrsp,
     75  Thread_Control     *thread,
     76  Priority_Control    initial_priority
     77)
     78{
     79  /*
     80   * The Thread_Control::resource_count is used by the normal priority ceiling
     81   * or priority inheritance semaphores.
     82   */
     83  if ( thread->resource_count == 0 ) {
     84    Priority_Control new_priority = _Scheduler_Highest_priority_of_two(
     85      _Scheduler_Get( thread ),
     86      initial_priority,
     87      thread->real_priority
     88    );
     89
     90    _Thread_Change_priority( thread, new_priority, true );
     91  }
     92}
     93
    4494RTEMS_INLINE_ROUTINE void _MRSP_Claim_ownership(
    4595  MRSP_Control     *mrsp,
    4696  Thread_Control   *new_owner,
     97  Priority_Control  initial_priority,
    4798  Priority_Control  ceiling_priority
    4899)
    49100{
    50   ++new_owner->resource_count;
    51   mrsp->owner = new_owner;
    52   _Thread_Change_priority( new_owner, ceiling_priority, false );
     101  _Resource_Node_add_resource( &new_owner->Resource_node, &mrsp->Resource );
     102  _Resource_Set_owner( &mrsp->Resource, &new_owner->Resource_node );
     103  mrsp->initial_priority_of_owner = initial_priority;
     104  _MRSP_Elevate_priority( mrsp, new_owner, ceiling_priority );
    53105}
    54106
     
    78130  }
    79131
    80   mrsp->owner = NULL;
     132  _Resource_Initialize( &mrsp->Resource );
    81133  _Chain_Initialize_empty( &mrsp->Rivals );
    82134
     
    101153}
    102154
    103 RTEMS_INLINE_ROUTINE void _MRSP_Restore_priority( Thread_Control *thread )
    104 {
    105   _Thread_Change_priority( thread, thread->real_priority, true );
    106 }
    107 
    108155RTEMS_INLINE_ROUTINE void _MRSP_Add_state(
    109156  MRSP_Rival   *rival,
     
    128175RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Wait_for_ownership(
    129176  MRSP_Control      *mrsp,
     177  Resource_Node     *owner,
    130178  Thread_Control    *executing,
     179  Priority_Control   initial_priority,
    131180  Priority_Control   ceiling_priority,
    132181  Watchdog_Interval  timeout
     
    138187  unsigned int state;
    139188
    140   _Thread_Change_priority( executing, ceiling_priority, false );
     189  _MRSP_Elevate_priority( mrsp, executing, ceiling_priority );
    141190
    142191  rival.thread = executing;
    143192  _Atomic_Init_uint( &rival.state, MRSP_RIVAL_STATE_WAITING );
    144193  _Chain_Append_unprotected( &mrsp->Rivals, &rival.Node );
     194  _Resource_Add_rival( &mrsp->Resource, &executing->Resource_node );
     195  _Resource_Node_set_dependency( &executing->Resource_node, &mrsp->Resource );
     196  _MRSP_Set_root( &executing->Resource_node, owner );
    145197
    146198  if ( timeout > 0 ) {
     
    177229
    178230  if ( ( state & MRSP_RIVAL_STATE_NEW_OWNER ) != 0 ) {
    179     ++executing->resource_count;
    180 
     231    mrsp->initial_priority_of_owner = initial_priority;
    181232    status = MRSP_SUCCESSFUL;
    182233  } else {
    183     if ( executing->resource_count == 0 ) {
    184       _MRSP_Restore_priority( executing );
    185     }
     234    Resource_Node *executing_node = &executing->Resource_node;
     235
     236    _Resource_Node_extract( executing_node );
     237    _Resource_Node_set_dependency( executing_node, NULL );
     238    _MRSP_Set_root( executing_node, executing_node );
     239    _MRSP_Restore_priority( mrsp, executing, initial_priority );
    186240
    187241    status = MRSP_TIMEOUT;
     
    201255  const Scheduler_Control *scheduler = _Scheduler_Get( executing );
    202256  uint32_t scheduler_index = _Scheduler_Get_index( scheduler );
     257  Priority_Control initial_priority = executing->current_priority;
    203258  Priority_Control ceiling_priority =
    204259    _MRSP_Get_ceiling_priority( mrsp, scheduler_index );
    205260  bool priority_ok = !_Scheduler_Is_priority_higher_than(
    206261    scheduler,
    207     executing->current_priority,
     262    initial_priority,
    208263    ceiling_priority
    209264  );
     265  Resource_Node *owner;
    210266
    211267  if ( !priority_ok) {
     
    213269  }
    214270
    215   if ( mrsp->owner == NULL ) {
    216     _MRSP_Claim_ownership( mrsp, executing, ceiling_priority );
     271  owner = _Resource_Get_owner( &mrsp->Resource );
     272  if ( owner == NULL ) {
     273    _MRSP_Claim_ownership(
     274      mrsp,
     275      executing,
     276      initial_priority,
     277      ceiling_priority
     278    );
    217279    status = MRSP_SUCCESSFUL;
    218   } else if ( mrsp->owner == executing ) {
     280  } else if ( _Resource_Node_get_root( owner ) == &executing->Resource_node ) {
     281    /* Nested access or deadlock */
    219282    status = MRSP_UNSATISFIED;
    220283  } else if ( wait ) {
    221284    status = _MRSP_Wait_for_ownership(
    222285      mrsp,
     286      owner,
    223287      executing,
     288      initial_priority,
    224289      ceiling_priority,
    225290      timeout
     
    237302)
    238303{
    239   uint32_t resource_count = executing->resource_count;
    240 
    241   if ( mrsp->owner != executing ) {
     304  if ( _Resource_Get_owner( &mrsp->Resource ) != &executing->Resource_node ) {
    242305    return MRSP_NOT_OWNER_OF_RESOURCE;
    243306  }
    244307
    245   if ( resource_count == 1 ) {
    246     executing->resource_count = 0;
    247     _MRSP_Restore_priority( executing );
    248   } else {
    249     executing->resource_count = resource_count - 1;
    250   }
     308  if (
     309    !_Resource_Is_most_recently_obtained(
     310      &mrsp->Resource,
     311      &executing->Resource_node
     312    )
     313  ) {
     314    return MRSP_INCORRECT_STATE;
     315  }
     316
     317  _Resource_Extract( &mrsp->Resource );
     318  _MRSP_Restore_priority( mrsp, executing, mrsp->initial_priority_of_owner );
    251319
    252320  if ( _Chain_Is_empty( &mrsp->Rivals ) ) {
    253     mrsp->owner = NULL;
     321    _Resource_Set_owner( &mrsp->Resource, NULL );
    254322  } else {
    255323    MRSP_Rival *rival = (MRSP_Rival *) _Chain_First( &mrsp->Rivals );
    256 
    257     mrsp->owner = rival->thread;
     324    Resource_Node *new_owner = &rival->thread->Resource_node;
     325
     326    _Resource_Node_extract( new_owner );
     327    _Resource_Node_set_dependency( new_owner, NULL );
     328    _MRSP_Set_root( new_owner, new_owner );
     329    _Resource_Node_add_resource( new_owner, &mrsp->Resource );
     330    _Resource_Set_owner( &mrsp->Resource, new_owner );
    258331    _MRSP_Add_state( rival, MRSP_RIVAL_STATE_NEW_OWNER );
    259332  }
     
    264337RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Destroy( MRSP_Control *mrsp )
    265338{
    266   if ( mrsp->owner != NULL ) {
     339  if ( _Resource_Get_owner( &mrsp->Resource ) != NULL ) {
    267340    return MRSP_RESOUCE_IN_USE;
    268341  }
  • doc/user/sem.t

    r3045738 r9553e7a6  
    752752component is set, then timeout is ignored.
    753753
     754Deadlock situations are detected for MrsP semaphores and the
     755@code{@value{RPREFIX}UNSATISFIED} status code will be returned on SMP
     756configurations in this case.
     757
    754758@subheading NOTES:
    755759The following semaphore acquisition option constants
     
    807811@code{@value{RPREFIX}SUCCESSFUL} - semaphore released successfully@*
    808812@code{@value{RPREFIX}INVALID_ID} - invalid semaphore id@*
    809 @code{@value{RPREFIX}NOT_OWNER_OF_RESOURCE} - calling task does not own semaphore
     813@code{@value{RPREFIX}NOT_OWNER_OF_RESOURCE} - calling task does not own semaphore@*
     814@code{@value{RPREFIX}INCORRECT_STATE} - invalid unlock order
    810815
    811816@subheading DESCRIPTION:
     
    838843the calling task holds no other binary semaphores and it has
    839844inherited a higher priority.
     845
     846The MrsP semaphores must be released in the reversed obtain order, otherwise
     847the @code{@value{RPREFIX}INCORRECT_STATE} status code will be returned on SMP
     848configurations in this case.
    840849
    841850@c
  • testsuites/smptests/smpmrsp01/init.c

    r3045738 r9553e7a6  
    4545  rtems_id scheduler_ids[CPU_COUNT];
    4646  rtems_id worker_ids[2 * CPU_COUNT];
     47  rtems_id timer_id;
    4748  volatile bool stop_worker[CPU_COUNT];
    4849  counter counters[2 * CPU_COUNT];
     
    355356
    356357  sc = rtems_semaphore_delete(id);
     358  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     359}
     360
     361static void test_mrsp_unlock_order_error(void)
     362{
     363  rtems_status_code sc;
     364  rtems_id id_a;
     365  rtems_id id_b;
     366
     367  puts("test MrsP unlock order error");
     368
     369  sc = rtems_semaphore_create(
     370    rtems_build_name(' ', ' ', ' ', 'A'),
     371    1,
     372    RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
     373      | RTEMS_BINARY_SEMAPHORE,
     374    1,
     375    &id_a
     376  );
     377  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     378
     379  sc = rtems_semaphore_create(
     380    rtems_build_name(' ', ' ', ' ', 'B'),
     381    1,
     382    RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
     383      | RTEMS_BINARY_SEMAPHORE,
     384    1,
     385    &id_b
     386  );
     387  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     388
     389  sc = rtems_semaphore_obtain(id_a, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     390  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     391
     392  sc = rtems_semaphore_obtain(id_b, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     393  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     394
     395  sc = rtems_semaphore_release(id_a);
     396  rtems_test_assert(sc == RTEMS_INCORRECT_STATE);
     397
     398  sc = rtems_semaphore_release(id_b);
     399  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     400
     401  sc = rtems_semaphore_release(id_a);
     402  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     403
     404  sc = rtems_semaphore_delete(id_a);
     405  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     406
     407  sc = rtems_semaphore_delete(id_b);
     408  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     409}
     410
     411static void deadlock_timer(rtems_id id, void *arg)
     412{
     413  test_context *ctx = &test_instance;
     414  rtems_status_code sc;
     415
     416  sc = rtems_task_suspend(ctx->worker_ids[0]);
     417  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     418}
     419
     420static void deadlock_worker(rtems_task_argument arg)
     421{
     422  test_context *ctx = &test_instance;
     423  rtems_status_code sc;
     424
     425  sc = rtems_semaphore_obtain(ctx->mrsp_ids[1], RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     426  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     427
     428  sc = rtems_timer_fire_after(ctx->timer_id, 2, deadlock_timer, NULL);
     429  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     430
     431  sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     432  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     433
     434  sc = rtems_semaphore_release(ctx->mrsp_ids[0]);
     435  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     436
     437  sc = rtems_semaphore_release(ctx->mrsp_ids[1]);
     438  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     439
     440  sc = rtems_event_transient_send(ctx->main_task_id);
     441  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     442
     443  rtems_task_suspend(RTEMS_SELF);
     444  rtems_test_assert(0);
     445}
     446
     447static void test_mrsp_deadlock_error(void)
     448{
     449  test_context *ctx = &test_instance;
     450  rtems_status_code sc;
     451  rtems_task_priority prio = 2;
     452
     453  puts("test MrsP deadlock error");
     454
     455  assert_prio(RTEMS_SELF, prio);
     456
     457  sc = rtems_timer_create(
     458    rtems_build_name('M', 'R', 'S', 'P'),
     459    &ctx->timer_id
     460  );
     461  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     462
     463  sc = rtems_semaphore_create(
     464    rtems_build_name(' ', ' ', ' ', 'A'),
     465    1,
     466    RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
     467      | RTEMS_BINARY_SEMAPHORE,
     468    prio,
     469    &ctx->mrsp_ids[0]
     470  );
     471  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     472
     473  sc = rtems_semaphore_create(
     474    rtems_build_name(' ', ' ', ' ', 'B'),
     475    1,
     476    RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
     477      | RTEMS_BINARY_SEMAPHORE,
     478    prio,
     479    &ctx->mrsp_ids[1]
     480  );
     481  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     482
     483  sc = rtems_task_create(
     484    rtems_build_name('W', 'O', 'R', 'K'),
     485    prio,
     486    RTEMS_MINIMUM_STACK_SIZE,
     487    RTEMS_DEFAULT_MODES,
     488    RTEMS_DEFAULT_ATTRIBUTES,
     489    &ctx->worker_ids[0]
     490  );
     491  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     492
     493  sc = rtems_task_start(ctx->worker_ids[0], deadlock_worker, 0);
     494  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     495
     496  sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     497  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     498
     499  sc = rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
     500  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     501
     502  sc = rtems_semaphore_obtain(ctx->mrsp_ids[1], RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     503  rtems_test_assert(sc == RTEMS_UNSATISFIED);
     504
     505  sc = rtems_semaphore_release(ctx->mrsp_ids[0]);
     506  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     507
     508  sc = rtems_task_resume(ctx->worker_ids[0]);
     509  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     510
     511  sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     512  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     513
     514  sc = rtems_task_delete(ctx->worker_ids[0]);
     515  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     516
     517  sc = rtems_semaphore_delete(ctx->mrsp_ids[0]);
     518  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     519
     520  sc = rtems_semaphore_delete(ctx->mrsp_ids[1]);
     521  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     522
     523  sc = rtems_timer_delete(ctx->timer_id);
     524  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     525}
     526
     527static void test_mrsp_multiple_obtain(void)
     528{
     529  rtems_status_code sc;
     530  rtems_id sem_a_id;
     531  rtems_id sem_b_id;
     532  rtems_id sem_c_id;
     533
     534  puts("test MrsP multiple obtain");
     535
     536  change_prio(RTEMS_SELF, 4);
     537
     538  sc = rtems_semaphore_create(
     539    rtems_build_name(' ', ' ', ' ', 'A'),
     540    1,
     541    RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
     542      | RTEMS_BINARY_SEMAPHORE,
     543    3,
     544    &sem_a_id
     545  );
     546  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     547
     548  sc = rtems_semaphore_create(
     549    rtems_build_name(' ', ' ', ' ', 'B'),
     550    1,
     551    RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
     552      | RTEMS_BINARY_SEMAPHORE,
     553    2,
     554    &sem_b_id
     555  );
     556  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     557
     558  sc = rtems_semaphore_create(
     559    rtems_build_name(' ', ' ', ' ', 'C'),
     560    1,
     561    RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
     562      | RTEMS_BINARY_SEMAPHORE,
     563    1,
     564    &sem_c_id
     565  );
     566  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     567
     568  assert_prio(RTEMS_SELF, 4);
     569
     570  sc = rtems_semaphore_obtain(sem_a_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     571  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     572
     573  assert_prio(RTEMS_SELF, 3);
     574
     575  sc = rtems_semaphore_obtain(sem_b_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     576  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     577
     578  assert_prio(RTEMS_SELF, 2);
     579
     580  sc = rtems_semaphore_obtain(sem_c_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     581  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     582
     583  assert_prio(RTEMS_SELF, 1);
     584
     585  sc = rtems_semaphore_release(sem_c_id);
     586  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     587
     588  assert_prio(RTEMS_SELF, 2);
     589
     590  sc = rtems_semaphore_release(sem_b_id);
     591  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     592
     593  assert_prio(RTEMS_SELF, 3);
     594
     595  sc = rtems_semaphore_release(sem_a_id);
     596  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     597
     598  assert_prio(RTEMS_SELF, 4);
     599
     600  sc = rtems_semaphore_obtain(sem_a_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     601  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     602
     603  assert_prio(RTEMS_SELF, 3);
     604
     605  sc = rtems_semaphore_obtain(sem_b_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     606  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     607
     608  assert_prio(RTEMS_SELF, 2);
     609
     610  sc = rtems_semaphore_obtain(sem_c_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     611  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     612
     613  assert_prio(RTEMS_SELF, 1);
     614  change_prio(RTEMS_SELF, 3);
     615  assert_prio(RTEMS_SELF, 1);
     616
     617  sc = rtems_semaphore_release(sem_c_id);
     618  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     619
     620  assert_prio(RTEMS_SELF, 2);
     621
     622  sc = rtems_semaphore_release(sem_b_id);
     623  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     624
     625  assert_prio(RTEMS_SELF, 3);
     626
     627  sc = rtems_semaphore_release(sem_a_id);
     628  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     629
     630  assert_prio(RTEMS_SELF, 3);
     631
     632  sc = rtems_semaphore_delete(sem_a_id);
     633  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     634
     635  sc = rtems_semaphore_delete(sem_b_id);
     636  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     637
     638  sc = rtems_semaphore_delete(sem_c_id);
     639  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     640
     641  change_prio(RTEMS_SELF, 2);
    357642  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
    358643}
     
    590875  test_mrsp_initially_locked_error();
    591876  test_mrsp_nested_obtain_error();
     877  test_mrsp_unlock_order_error();
     878  test_mrsp_deadlock_error();
     879  test_mrsp_multiple_obtain();
    592880  test_mrsp_obtain_and_release();
    593881  test_mrsp_load();
Note: See TracChangeset for help on using the changeset viewer.