Changeset 62c528e6 in rtems


Ignore:
Timestamp:
May 20, 2016, 12:59:30 PM (4 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
master
Children:
4bae341
Parents:
641b44c
git-author:
Sebastian Huber <sebastian.huber@…> (05/20/16 12:59:30)
git-committer:
Sebastian Huber <sebastian.huber@…> (05/20/16 14:17:00)
Message:

rtems: _Semaphore_Get_interrupt_disable()

Use _Objects_Get_local() for _Semaphore_Get_interrupt_disable() to get
rid of the location parameter. Move remote object handling to semaphore
MPCI support.

Files:
10 edited

Legend:

Unmodified
Added
Removed
  • cpukit/rtems/include/rtems/rtems/semimpl.h

    r641b44c r62c528e6  
    135135}
    136136
    137 /**
    138  *  @brief Maps semaphore IDs to semaphore control blocks.
    139  *
    140  *  This function maps semaphore IDs to semaphore control blocks.
    141  *  If ID corresponds to a local semaphore, then it returns
    142  *  the_semaphore control pointer which maps to ID and location
    143  *  is set to OBJECTS_LOCAL.  if the semaphore ID is global and
    144  *  resides on a remote node, then location is set to OBJECTS_REMOTE,
    145  *  and the_semaphore is undefined.  Otherwise, location is set
    146  *  to OBJECTS_ERROR and the_semaphore is undefined.
    147  */
    148 RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get_interrupt_disable (
     137RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get_interrupt_disable(
    149138  Objects_Id         id,
    150   Objects_Locations *location,
    151139  ISR_lock_Context  *lock_context
    152140)
    153141{
    154   return (Semaphore_Control *) _Objects_Get_isr_disable(
    155     &_Semaphore_Information,
     142  return (Semaphore_Control *) _Objects_Get_local(
    156143    id,
    157     location,
    158     lock_context
     144    lock_context,
     145    &_Semaphore_Information
    159146  );
    160147}
  • cpukit/rtems/include/rtems/rtems/semmp.h

    r641b44c r62c528e6  
    6666}   Semaphore_MP_Packet;
    6767
     68RTEMS_INLINE_ROUTINE bool _Semaphore_MP_Is_remote( Objects_Id id )
     69{
     70  return _Objects_MP_Is_remote( id, &_Semaphore_Information );
     71}
     72
    6873/**
    6974 *  @brief Semaphore MP Send Process Packet
     
    8085
    8186/**
    82  *  @brief Semaphore MP Send Request Packet
    83  *
    84  *  This routine performs a remote procedure call so that a
    85  *  directive operation can be initiated on another node.
     87 * @brief Issues a remote rtems_semaphore_obtain() request.
    8688 */
    87 rtems_status_code _Semaphore_MP_Send_request_packet (
    88   Semaphore_MP_Remote_operations operation,
    89   Objects_Id                     semaphore_id,
    90   rtems_option                   option_set,
    91   rtems_interval                 timeout
     89rtems_status_code _Semaphore_MP_Obtain(
     90  rtems_id        id,
     91  rtems_option    option_set,
     92  rtems_interval  timeout
    9293);
     94
     95/**
     96 * @brief Issues a remote rtems_semaphore_release() request.
     97 */
     98rtems_status_code _Semaphore_MP_Release( rtems_id id );
    9399
    94100/**
  • cpukit/rtems/src/semdelete.c

    r641b44c r62c528e6  
    1919#endif
    2020
    21 #include <rtems/system.h>
    22 #include <rtems/rtems/status.h>
    23 #include <rtems/rtems/support.h>
     21#include <rtems/rtems/semimpl.h>
    2422#include <rtems/rtems/attrimpl.h>
    25 #include <rtems/score/isr.h>
    26 #include <rtems/rtems/options.h>
    27 #include <rtems/rtems/semimpl.h>
    28 #include <rtems/score/coremuteximpl.h>
    29 #include <rtems/score/coresemimpl.h>
    30 #include <rtems/score/thread.h>
    31 
    32 #include <rtems/score/interr.h>
    3323
    3424rtems_status_code rtems_semaphore_delete(
     
    3626)
    3727{
    38   Semaphore_Control          *the_semaphore;
    39   Objects_Locations           location;
    40   ISR_lock_Context            lock_context;
    41   rtems_attribute             attribute_set;
     28  Semaphore_Control *the_semaphore;
     29  ISR_lock_Context   lock_context;
     30  rtems_attribute    attribute_set;
    4231
    4332  _Objects_Allocator_lock();
     33  the_semaphore = _Semaphore_Get_interrupt_disable( id, &lock_context );
    4434
    45   the_semaphore = _Semaphore_Get_interrupt_disable(
    46     id,
    47     &location,
    48     &lock_context
    49   );
    50   switch ( location ) {
     35  if ( the_semaphore == NULL ) {
     36    _Objects_Allocator_unlock();
    5137
    52     case OBJECTS_LOCAL:
    53       attribute_set = the_semaphore->attribute_set;
    54 #if defined(RTEMS_SMP)
    55       if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
    56         MRSP_Status mrsp_status;
     38#if defined(RTEMS_MULTIPROCESSING)
     39    if ( _Semaphore_MP_Is_remote( id ) ) {
     40      return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
     41    }
     42#endif
    5743
    58         _MRSP_Acquire_critical(
    59           &the_semaphore->Core_control.mrsp,
    60           &lock_context
    61         );
    62         mrsp_status = _MRSP_Can_destroy( &the_semaphore->Core_control.mrsp );
    63         if ( mrsp_status != MRSP_SUCCESSFUL ) {
    64           _MRSP_Release(
    65             &the_semaphore->Core_control.mrsp,
    66             &lock_context
    67           );
    68           _Objects_Allocator_unlock();
    69           return _Semaphore_Translate_MRSP_status_code( mrsp_status );
    70         }
    71       } else
    72 #endif
    73       if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
    74         _CORE_mutex_Acquire_critical(
    75           &the_semaphore->Core_control.mutex,
    76           &lock_context
    77         );
     44    return RTEMS_INVALID_ID;
     45  }
    7846
    79         if (
    80           _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex )
    81             && !_Attributes_Is_simple_binary_semaphore( attribute_set )
    82         ) {
    83           _CORE_mutex_Release(
    84             &the_semaphore->Core_control.mutex,
    85             &lock_context
    86           );
    87           _Objects_Allocator_unlock();
    88           return RTEMS_RESOURCE_IN_USE;
    89         }
    90       } else {
    91         _CORE_semaphore_Acquire_critical(
    92           &the_semaphore->Core_control.semaphore,
    93           &lock_context
    94         );
    95       }
    96 
    97       _Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
     47  attribute_set = the_semaphore->attribute_set;
    9848
    9949#if defined(RTEMS_SMP)
    100       if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
    101         _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &lock_context );
    102       } else
     50  if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
     51    MRSP_Status mrsp_status;
     52
     53    _MRSP_Acquire_critical(
     54      &the_semaphore->Core_control.mrsp,
     55      &lock_context
     56    );
     57    mrsp_status = _MRSP_Can_destroy( &the_semaphore->Core_control.mrsp );
     58    if ( mrsp_status != MRSP_SUCCESSFUL ) {
     59      _MRSP_Release(
     60        &the_semaphore->Core_control.mrsp,
     61        &lock_context
     62      );
     63      _Objects_Allocator_unlock();
     64      return _Semaphore_Translate_MRSP_status_code( mrsp_status );
     65    }
     66  } else
    10367#endif
    104       if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
    105         _CORE_mutex_Flush(
    106           &the_semaphore->Core_control.mutex,
    107           _CORE_mutex_Was_deleted,
    108           _Semaphore_MP_Send_object_was_deleted,
    109           id,
    110           &lock_context
    111         );
    112         _CORE_mutex_Destroy( &the_semaphore->Core_control.mutex );
    113       } else {
    114         _CORE_semaphore_Destroy(
    115           &the_semaphore->Core_control.semaphore,
    116           _Semaphore_MP_Send_object_was_deleted,
    117           id,
    118           &lock_context
    119         );
    120       }
     68  if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     69    _CORE_mutex_Acquire_critical(
     70      &the_semaphore->Core_control.mutex,
     71      &lock_context
     72    );
     73
     74    if (
     75      _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex )
     76        && !_Attributes_Is_simple_binary_semaphore( attribute_set )
     77    ) {
     78      _CORE_mutex_Release(
     79        &the_semaphore->Core_control.mutex,
     80        &lock_context
     81      );
     82      _Objects_Allocator_unlock();
     83      return RTEMS_RESOURCE_IN_USE;
     84    }
     85  } else {
     86    _CORE_semaphore_Acquire_critical(
     87      &the_semaphore->Core_control.semaphore,
     88      &lock_context
     89    );
     90  }
     91
     92  _Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
     93
     94#if defined(RTEMS_SMP)
     95  if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
     96    _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &lock_context );
     97  } else
     98#endif
     99  if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     100    _CORE_mutex_Flush(
     101      &the_semaphore->Core_control.mutex,
     102      _CORE_mutex_Was_deleted,
     103      _Semaphore_MP_Send_object_was_deleted,
     104      id,
     105      &lock_context
     106    );
     107    _CORE_mutex_Destroy( &the_semaphore->Core_control.mutex );
     108  } else {
     109    _CORE_semaphore_Destroy(
     110      &the_semaphore->Core_control.semaphore,
     111      _Semaphore_MP_Send_object_was_deleted,
     112      id,
     113      &lock_context
     114    );
     115  }
    121116
    122117#if defined(RTEMS_MULTIPROCESSING)
    123       if ( _Attributes_Is_global( attribute_set ) ) {
     118  if ( _Attributes_Is_global( attribute_set ) ) {
    124119
    125         _Objects_MP_Close( &_Semaphore_Information, id );
     120    _Objects_MP_Close( &_Semaphore_Information, id );
    126121
    127         _Semaphore_MP_Send_process_packet(
    128           SEMAPHORE_MP_ANNOUNCE_DELETE,
    129           id,
    130           0,                         /* Not used */
    131           0                          /* Not used */
    132         );
    133       }
     122    _Semaphore_MP_Send_process_packet(
     123      SEMAPHORE_MP_ANNOUNCE_DELETE,
     124      id,
     125      0,                         /* Not used */
     126      0                          /* Not used */
     127    );
     128  }
    134129#endif
    135130
    136       _Semaphore_Free( the_semaphore );
    137       _Objects_Allocator_unlock();
    138       return RTEMS_SUCCESSFUL;
    139 
    140 #if defined(RTEMS_MULTIPROCESSING)
    141     case OBJECTS_REMOTE:
    142       _Objects_Allocator_unlock();
    143       return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
    144 #endif
    145 
    146     case OBJECTS_ERROR:
    147       break;
    148   }
    149 
     131  _Semaphore_Free( the_semaphore );
    150132  _Objects_Allocator_unlock();
    151   return RTEMS_INVALID_ID;
     133  return RTEMS_SUCCESSFUL;
    152134}
  • cpukit/rtems/src/semflush.c

    r641b44c r62c528e6  
    1919#endif
    2020
    21 #include <rtems/system.h>
    22 #include <rtems/rtems/status.h>
    23 #include <rtems/rtems/support.h>
     21#include <rtems/rtems/semimpl.h>
    2422#include <rtems/rtems/attrimpl.h>
    25 #include <rtems/score/isr.h>
    26 #include <rtems/rtems/options.h>
    27 #include <rtems/rtems/semimpl.h>
    28 #include <rtems/score/coremuteximpl.h>
    29 #include <rtems/score/coresemimpl.h>
    30 #include <rtems/score/thread.h>
    3123
    32 #include <rtems/score/interr.h>
     24rtems_status_code rtems_semaphore_flush( rtems_id id )
     25{
     26  Semaphore_Control *the_semaphore;
     27  ISR_lock_Context   lock_context;
     28  rtems_attribute    attribute_set;
    3329
    34 rtems_status_code rtems_semaphore_flush(
    35   rtems_id        id
    36 )
    37 {
    38   Semaphore_Control          *the_semaphore;
    39   Objects_Locations           location;
    40   ISR_lock_Context            lock_context;
    41   rtems_attribute             attribute_set;
     30  the_semaphore = _Semaphore_Get_interrupt_disable( id, &lock_context );
    4231
    43   the_semaphore = _Semaphore_Get_interrupt_disable(
    44     id,
    45     &location,
    46     &lock_context
    47   );
    48   switch ( location ) {
    49 
    50     case OBJECTS_LOCAL:
    51       attribute_set = the_semaphore->attribute_set;
    52 #if defined(RTEMS_SMP)
    53       if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
    54         _ISR_lock_ISR_enable( &lock_context );
    55         return RTEMS_NOT_DEFINED;
    56       } else
    57 #endif
    58       if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
    59         _CORE_mutex_Acquire_critical(
    60           &the_semaphore->Core_control.mutex,
    61           &lock_context
    62         );
    63         _CORE_mutex_Flush(
    64           &the_semaphore->Core_control.mutex,
    65           _CORE_mutex_Unsatisfied_nowait,
    66           _Semaphore_MP_Send_object_was_deleted,
    67           id,
    68           &lock_context
    69         );
    70       } else {
    71         _CORE_semaphore_Acquire_critical(
    72           &the_semaphore->Core_control.semaphore,
    73           &lock_context
    74         );
    75         _CORE_semaphore_Flush(
    76           &the_semaphore->Core_control.semaphore,
    77           _Semaphore_MP_Send_object_was_deleted,
    78           id,
    79           &lock_context
    80         );
    81       }
    82       return RTEMS_SUCCESSFUL;
    83 
     32  if ( the_semaphore == NULL ) {
    8433#if defined(RTEMS_MULTIPROCESSING)
    85     case OBJECTS_REMOTE:
     34    if ( _Semaphore_MP_Is_remote( id ) ) {
    8635      return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
     36    }
    8737#endif
    8838
    89     case OBJECTS_ERROR:
    90       break;
     39    return RTEMS_INVALID_ID;
    9140  }
    9241
    93   return RTEMS_INVALID_ID;
     42  attribute_set = the_semaphore->attribute_set;
     43
     44#if defined(RTEMS_SMP)
     45  if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
     46    _ISR_lock_ISR_enable( &lock_context );
     47    return RTEMS_NOT_DEFINED;
     48  } else
     49#endif
     50  if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     51    _CORE_mutex_Acquire_critical(
     52      &the_semaphore->Core_control.mutex,
     53      &lock_context
     54    );
     55    _CORE_mutex_Flush(
     56      &the_semaphore->Core_control.mutex,
     57      _CORE_mutex_Unsatisfied_nowait,
     58      _Semaphore_MP_Send_object_was_deleted,
     59      id,
     60      &lock_context
     61    );
     62  } else {
     63    _CORE_semaphore_Acquire_critical(
     64      &the_semaphore->Core_control.semaphore,
     65      &lock_context
     66    );
     67    _CORE_semaphore_Flush(
     68      &the_semaphore->Core_control.semaphore,
     69      _Semaphore_MP_Send_object_was_deleted,
     70      id,
     71      &lock_context
     72    );
     73  }
     74  return RTEMS_SUCCESSFUL;
    9475}
  • cpukit/rtems/src/semmp.c

    r641b44c r62c528e6  
    7373}
    7474
    75 rtems_status_code _Semaphore_MP_Send_request_packet (
    76   Semaphore_MP_Remote_operations operation,
     75static rtems_status_code _Semaphore_MP_Send_request_packet(
    7776  Objects_Id                     semaphore_id,
    7877  rtems_option                   option_set,
    79   rtems_interval                 timeout
     78  rtems_interval                 timeout,
     79  Semaphore_MP_Remote_operations operation
    8080)
    8181{
     
    121121}
    122122
     123rtems_status_code _Semaphore_MP_Obtain(
     124  rtems_id        id,
     125  rtems_option    option_set,
     126  rtems_interval  timeout
     127)
     128{
     129  return _Semaphore_MP_Send_request_packet(
     130    id,
     131    option_set,
     132    timeout,
     133    SEMAPHORE_MP_OBTAIN_REQUEST
     134  );
     135}
     136
     137rtems_status_code _Semaphore_MP_Release( rtems_id id )
     138{
     139  return _Semaphore_MP_Send_request_packet(
     140    id,
     141    0,
     142    MPCI_DEFAULT_TIMEOUT,
     143    SEMAPHORE_MP_RELEASE_REQUEST
     144  );
     145}
     146
    123147static void _Semaphore_MP_Send_response_packet (
    124148  Semaphore_MP_Remote_operations  operation,
  • cpukit/rtems/src/semobtain.c

    r641b44c r62c528e6  
    1919#endif
    2020
    21 #include <rtems/system.h>
    22 #include <rtems/rtems/status.h>
    23 #include <rtems/rtems/support.h>
     21#include <rtems/rtems/semimpl.h>
     22#include <rtems/score/threadimpl.h>
    2423#include <rtems/rtems/attrimpl.h>
    25 #include <rtems/score/isr.h>
    2624#include <rtems/rtems/optionsimpl.h>
    27 #include <rtems/rtems/semimpl.h>
    28 #include <rtems/score/coremuteximpl.h>
    29 #include <rtems/score/coresemimpl.h>
    30 #include <rtems/score/threadimpl.h>
    31 
    32 #include <rtems/score/interr.h>
    3325
    3426THREAD_WAIT_QUEUE_OBJECT_ASSERT(
     
    4840)
    4941{
    50   Semaphore_Control              *the_semaphore;
    51   Objects_Locations               location;
    52   ISR_lock_Context                lock_context;
    53   Thread_Control                 *executing;
    54   rtems_attribute                 attribute_set;
    55   bool                            wait;
     42  Semaphore_Control *the_semaphore;
     43  ISR_lock_Context   lock_context;
     44  Thread_Control    *executing;
     45  rtems_attribute    attribute_set;
     46  bool               wait;
    5647
    57   the_semaphore = _Semaphore_Get_interrupt_disable(
     48  the_semaphore = _Semaphore_Get_interrupt_disable( id, &lock_context );
     49
     50  if ( the_semaphore == NULL ) {
     51#if defined(RTEMS_MULTIPROCESSING)
     52    _Semaphore_MP_Obtain( id, option_set, timeout );
     53#else
     54    return RTEMS_INVALID_ID;
     55#endif
     56  }
     57
     58  executing = _Thread_Executing;
     59  attribute_set = the_semaphore->attribute_set;
     60  wait = !_Options_Is_no_wait( option_set );
     61#if defined(RTEMS_SMP)
     62  if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
     63    MRSP_Status mrsp_status;
     64
     65    mrsp_status = _MRSP_Seize(
     66      &the_semaphore->Core_control.mrsp,
     67      executing,
     68      wait,
     69      timeout,
     70      &lock_context
     71    );
     72    return _Semaphore_Translate_MRSP_status_code( mrsp_status );
     73  } else
     74#endif
     75  if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     76    _CORE_mutex_Seize(
     77      &the_semaphore->Core_control.mutex,
     78      executing,
     79      wait,
     80      timeout,
     81      &lock_context
     82    );
     83    return _Semaphore_Translate_core_mutex_return_code(
     84      executing->Wait.return_code
     85    );
     86  }
     87
     88  /* must be a counting semaphore */
     89  _CORE_semaphore_Seize(
     90    &the_semaphore->Core_control.semaphore,
     91    executing,
    5892    id,
    59     &location,
     93    wait,
     94    timeout,
    6095    &lock_context
    6196  );
    62   switch ( location ) {
    63 
    64     case OBJECTS_LOCAL:
    65       executing = _Thread_Executing;
    66       attribute_set = the_semaphore->attribute_set;
    67       wait = !_Options_Is_no_wait( option_set );
    68 #if defined(RTEMS_SMP)
    69       if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
    70         MRSP_Status mrsp_status;
    71 
    72         mrsp_status = _MRSP_Seize(
    73           &the_semaphore->Core_control.mrsp,
    74           executing,
    75           wait,
    76           timeout,
    77           &lock_context
    78         );
    79         return _Semaphore_Translate_MRSP_status_code( mrsp_status );
    80       } else
    81 #endif
    82       if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
    83         _CORE_mutex_Seize(
    84           &the_semaphore->Core_control.mutex,
    85           executing,
    86           wait,
    87           timeout,
    88           &lock_context
    89         );
    90         return _Semaphore_Translate_core_mutex_return_code(
    91                   executing->Wait.return_code );
    92       }
    93 
    94       /* must be a counting semaphore */
    95       _CORE_semaphore_Seize(
    96         &the_semaphore->Core_control.semaphore,
    97         executing,
    98         id,
    99         wait,
    100         timeout,
    101         &lock_context
    102       );
    103       return _Semaphore_Translate_core_semaphore_return_code(
    104                   executing->Wait.return_code );
    105 
    106 #if defined(RTEMS_MULTIPROCESSING)
    107     case OBJECTS_REMOTE:
    108       return _Semaphore_MP_Send_request_packet(
    109           SEMAPHORE_MP_OBTAIN_REQUEST,
    110           id,
    111           option_set,
    112           timeout
    113       );
    114 #endif
    115 
    116     case OBJECTS_ERROR:
    117       break;
    118 
    119   }
    120 
    121   return RTEMS_INVALID_ID;
     97  return _Semaphore_Translate_core_semaphore_return_code(
     98    executing->Wait.return_code
     99  );
    122100}
  • cpukit/rtems/src/semrelease.c

    r641b44c r62c528e6  
    2222#endif
    2323
    24 #include <rtems/system.h>
    25 #include <rtems/rtems/status.h>
    26 #include <rtems/rtems/support.h>
     24#include <rtems/rtems/semimpl.h>
    2725#include <rtems/rtems/attrimpl.h>
    28 #include <rtems/score/isr.h>
    29 #include <rtems/rtems/options.h>
    30 #include <rtems/rtems/semimpl.h>
    31 #include <rtems/score/coremuteximpl.h>
    32 #include <rtems/score/coresemimpl.h>
    33 #include <rtems/score/thread.h>
    34 #include <rtems/score/interr.h>
    3526
    36 rtems_status_code rtems_semaphore_release(
    37   rtems_id   id
    38 )
     27rtems_status_code rtems_semaphore_release( rtems_id id )
    3928{
    40   Semaphore_Control          *the_semaphore;
    41   Objects_Locations           location;
    42   CORE_mutex_Status           mutex_status;
    43   CORE_semaphore_Status       semaphore_status;
    44   rtems_attribute             attribute_set;
    45   ISR_lock_Context            lock_context;
     29  Semaphore_Control     *the_semaphore;
     30  CORE_mutex_Status      mutex_status;
     31  CORE_semaphore_Status  semaphore_status;
     32  rtems_attribute        attribute_set;
     33  ISR_lock_Context       lock_context;
    4634
    47   the_semaphore = _Semaphore_Get_interrupt_disable(
    48     id,
    49     &location,
    50     &lock_context
    51   );
    52   switch ( location ) {
     35  the_semaphore = _Semaphore_Get_interrupt_disable( id, &lock_context );
    5336
    54     case OBJECTS_LOCAL:
    55       attribute_set = the_semaphore->attribute_set;
    56 #if defined(RTEMS_SMP)
    57       if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
    58         MRSP_Status mrsp_status;
    59 
    60         mrsp_status = _MRSP_Surrender(
    61           &the_semaphore->Core_control.mrsp,
    62           _Thread_Executing,
    63           &lock_context
    64         );
    65         return _Semaphore_Translate_MRSP_status_code( mrsp_status );
    66       } else
     37  if ( the_semaphore == NULL ) {
     38#if defined(RTEMS_MULTIPROCESSING)
     39    _Semaphore_MP_Release( id );
     40#else
     41    return RTEMS_INVALID_ID;
    6742#endif
    68       if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
    69         mutex_status = _CORE_mutex_Surrender(
    70           &the_semaphore->Core_control.mutex,
    71           _Semaphore_Core_mutex_mp_support,
    72           id,
    73           &lock_context
    74         );
    75         return _Semaphore_Translate_core_mutex_return_code( mutex_status );
    76       } else {
    77         semaphore_status = _CORE_semaphore_Surrender(
    78           &the_semaphore->Core_control.semaphore,
    79           _Semaphore_Core_mutex_mp_support,
    80           id,
    81           &lock_context
    82         );
    83         return
    84           _Semaphore_Translate_core_semaphore_return_code( semaphore_status );
    85       }
    86 
    87 #if defined(RTEMS_MULTIPROCESSING)
    88     case OBJECTS_REMOTE:
    89       return _Semaphore_MP_Send_request_packet(
    90         SEMAPHORE_MP_RELEASE_REQUEST,
    91         id,
    92         0,                               /* Not used */
    93         MPCI_DEFAULT_TIMEOUT
    94       );
    95 #endif
    96 
    97     case OBJECTS_ERROR:
    98       break;
    9943  }
    10044
    101   return RTEMS_INVALID_ID;
     45  attribute_set = the_semaphore->attribute_set;
     46#if defined(RTEMS_SMP)
     47  if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
     48    MRSP_Status mrsp_status;
     49
     50    mrsp_status = _MRSP_Surrender(
     51      &the_semaphore->Core_control.mrsp,
     52      _Thread_Executing,
     53      &lock_context
     54    );
     55    return _Semaphore_Translate_MRSP_status_code( mrsp_status );
     56  } else
     57#endif
     58  if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     59    mutex_status = _CORE_mutex_Surrender(
     60      &the_semaphore->Core_control.mutex,
     61      _Semaphore_Core_mutex_mp_support,
     62      id,
     63      &lock_context
     64    );
     65    return _Semaphore_Translate_core_mutex_return_code( mutex_status );
     66  } else {
     67    semaphore_status = _CORE_semaphore_Surrender(
     68      &the_semaphore->Core_control.semaphore,
     69      _Semaphore_Core_mutex_mp_support,
     70      id,
     71      &lock_context
     72    );
     73    return _Semaphore_Translate_core_semaphore_return_code( semaphore_status );
     74  }
    10275}
  • cpukit/rtems/src/semsetpriority.c

    r641b44c r62c528e6  
    8989{
    9090  Semaphore_Control *the_semaphore;
    91   Objects_Locations  location;
    9291  ISR_lock_Context   lock_context;
    9392
     
    107106  the_semaphore = _Semaphore_Get_interrupt_disable(
    108107    semaphore_id,
    109     &location,
    110108    &lock_context
    111109  );
    112   switch ( location ) {
    113     case OBJECTS_LOCAL:
    114       return _Semaphore_Set_priority(
    115         the_semaphore,
    116         scheduler_id,
    117         new_priority,
    118         old_priority,
    119         &lock_context
    120       );
     110
     111  if ( the_semaphore == NULL ) {
    121112#if defined(RTEMS_MULTIPROCESSING)
    122     case OBJECTS_REMOTE:
     113    if ( _Semaphore_MP_Is_remote( semaphore_id ) ) {
    123114      return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
     115    }
    124116#endif
    125     case OBJECTS_ERROR:
    126       break;
     117
     118    return RTEMS_INVALID_ID;
    127119  }
    128120
    129   return RTEMS_INVALID_ID;
     121  return _Semaphore_Set_priority(
     122    the_semaphore,
     123    scheduler_id,
     124    new_priority,
     125    old_priority,
     126    &lock_context
     127  );
    130128}
  • testsuites/sptests/spintrcritical22/init.c

    r641b44c r62c528e6  
    3434static Semaphore_Control *get_semaphore_control(rtems_id id)
    3535{
    36   Objects_Locations location;
    3736  ISR_lock_Context lock_context;
    3837  Semaphore_Control *sem;
    3938
    40   sem = _Semaphore_Get_interrupt_disable(id, &location, &lock_context);
     39  sem = _Semaphore_Get_interrupt_disable(id, &lock_context);
    4140  rtems_test_assert(sem != NULL);
    4241  _ISR_lock_ISR_enable(&lock_context);
  • testsuites/tmtests/tm26/task1.c

    r641b44c r62c528e6  
    3131/* TEST DATA */
    3232rtems_id Semaphore_id;
    33 
    34 Objects_Locations location;   /* uses internal RTEMS type */
    3533
    3634Thread_Control *Middle_tcb;   /* uses internal RTEMS type */
     
    518516      (void) _Semaphore_Get_interrupt_disable(
    519517        Semaphore_id,
    520         &location,
    521518        &lock_context
    522519      );
Note: See TracChangeset for help on using the changeset viewer.