Changeset 3652ad35 in rtems for cpukit/rtems/src


Ignore:
Timestamp:
09/19/95 14:53:29 (27 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
38ffa0c
Parents:
b3ac6a8d
Message:

Minor bug fixes to get all targets compilable and running. The
single biggest changes were the expansion of the workspace size
macro to include other types of objects and the increase in the
minimum stack size for most CPUs.

Location:
cpukit/rtems/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • cpukit/rtems/src/msg.c

    rb3ac6a8d r3652ad35  
    1515
    1616#include <rtems/system.h>
    17 #include <rtems/rtems/status.h>
    18 #include <rtems/rtems/attr.h>
     17#include <rtems/sysstate.h>
    1918#include <rtems/core/chain.h>
    2019#include <rtems/core/isr.h>
    21 #include <rtems/rtems/message.h>
     20#include <rtems/core/coremsg.h>
    2221#include <rtems/core/object.h>
    23 #include <rtems/rtems/options.h>
    2422#include <rtems/core/states.h>
    25 #include <rtems/rtems/support.h>
    2623#include <rtems/core/thread.h>
    2724#include <rtems/core/wkspace.h>
    2825#include <rtems/core/mpci.h>
    29 #include <rtems/sysstate.h>
     26#include <rtems/rtems/status.h>
     27#include <rtems/rtems/attr.h>
     28#include <rtems/rtems/message.h>
     29#include <rtems/rtems/options.h>
     30#include <rtems/rtems/support.h>
    3031
    3132/*PAGE
     
    7374 *
    7475 *  Allocate a message queue and the space for its messages
     76 *
     77 *  Input parameters:
     78 *    the_message_queue - the message queue to allocate message buffers
     79 *    count             - maximum message and reserved buffer count
     80 *    max_message_size  - maximum size of each message
     81 *
     82 *  Output parameters:
     83 *    the_message_queue - set if successful, NULL otherwise
    7584 */
    7685
    7786Message_queue_Control *_Message_queue_Allocate (
    78   unsigned32          count,
    79   unsigned32          max_message_size
    80 )
    81 {
    82     Message_queue_Control *mq = 0;
    83     unsigned32 message_buffering_required;
    84     unsigned32 allocated_message_size;
    85 
    86     mq =
    87       (Message_queue_Control *)_Objects_Allocate(&_Message_queue_Information);
    88 
    89     if (mq == 0)
    90         goto failed;
    91 
    92     mq->maximum_message_size = max_message_size;
    93 
    94     /*
    95      * round size up to multiple of a ptr for chain init
    96      */
    97    
    98     allocated_message_size = max_message_size;
    99     if (allocated_message_size & (sizeof(unsigned32) - 1)) {
    100         allocated_message_size += sizeof(unsigned32);
    101         allocated_message_size &= ~(sizeof(unsigned32) - 1);
    102     }
    103    
    104     message_buffering_required =
    105       count * (allocated_message_size + sizeof(Message_queue_Buffer_control));
    106  
    107     mq->message_buffers =
    108       (Message_queue_Buffer *) _Workspace_Allocate(message_buffering_required);
    109 
    110     if (mq->message_buffers == 0)
    111         goto failed;
    112  
    113     _Chain_Initialize
    114       (&mq->Inactive_messages,
    115       mq->message_buffers,
    116       count,
    117       allocated_message_size + sizeof(Message_queue_Buffer_control)
    118     );
    119     return mq;
    120 
    121 failed:
    122     if (mq)
    123         _Message_queue_Free(mq);
    124     return (Message_queue_Control *) 0;
     87  unsigned32           count,
     88  unsigned32           max_message_size
     89)
     90{
     91  return
     92    (Message_queue_Control *)_Objects_Allocate(&_Message_queue_Information);
     93
    12594}
    12695
     
    133102 *
    134103 *  Input parameters:
    135  *    name          - user defined queue name
    136  *    count         - maximum message and reserved buffer count
     104 *    name             - user defined queue name
     105 *    count            - maximum message and reserved buffer count
    137106 *    max_message_size - maximum size of each message
    138  *    attribute_set - process method
    139  *    id            - pointer to queue
     107 *    attribute_set    - process method
     108 *    id               - pointer to queue
    140109 *
    141110 *  Output parameters:
     
    154123{
    155124  register Message_queue_Control *the_message_queue;
     125  CORE_message_queue_Attributes   the_message_queue_attributes;
     126  boolean                         is_global;
    156127
    157128  if ( !rtems_is_name_valid( name ) )
    158129    return RTEMS_INVALID_NAME;
    159130
    160   if ( _Attributes_Is_global( attribute_set ) &&
     131  if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
    161132       !_System_state_Is_multiprocessing )
    162133    return RTEMS_MP_NOT_CONFIGURED;
     
    175146   */
    176147 
    177   if ( _Attributes_Is_global( attribute_set ) &&
    178        (_MPCI_table->maximum_packet_size < max_message_size))
    179   {
    180       return RTEMS_INVALID_SIZE;
    181   }
     148  if ( is_global && (_MPCI_table->maximum_packet_size < max_message_size) )
     149    return RTEMS_INVALID_SIZE;
     150
    182151#endif
    183152       
    184153  _Thread_Disable_dispatch();              /* protects object pointer */
    185154
    186   the_message_queue = _Message_queue_Allocate(count, max_message_size);
     155  the_message_queue = _Message_queue_Allocate( count, max_message_size );
    187156
    188157  if ( !the_message_queue ) {
     
    191160  }
    192161
    193   if ( _Attributes_Is_global( attribute_set ) &&
    194        !( _Objects_MP_Allocate_and_open( &_Message_queue_Information, name,
    195                             the_message_queue->Object.id, FALSE ) ) ) {
     162  if ( is_global &&
     163    !( _Objects_MP_Allocate_and_open( &_Message_queue_Information,
     164                              name, the_message_queue->Object.id, FALSE ) ) ) {
    196165    _Message_queue_Free( the_message_queue );
    197166    _Thread_Enable_dispatch();
     
    199168  }
    200169
    201   the_message_queue->maximum_pending_messages = count;
    202 
    203170  the_message_queue->attribute_set = attribute_set;
    204   the_message_queue->number_of_pending_messages = 0;
    205 
    206   _Chain_Initialize_empty( &the_message_queue->Pending_messages );
    207 
    208   _Thread_queue_Initialize(
    209     &the_message_queue->Wait_queue,
    210     OBJECTS_RTEMS_MESSAGE_QUEUES,
    211     _Attributes_Is_priority( attribute_set ) ?
    212        THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    213     STATES_WAITING_FOR_MESSAGE,
    214     _Message_queue_MP_Send_extract_proxy,
    215     RTEMS_TIMEOUT
    216   );
     171
     172  if (_Attributes_Is_priority( attribute_set ) )
     173    the_message_queue_attributes.discipline =
     174                                      CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
     175  else
     176    the_message_queue_attributes.discipline =
     177                                      CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
     178
     179  if ( ! _CORE_message_queue_Initialize(
     180           &the_message_queue->message_queue,
     181           OBJECTS_RTEMS_MESSAGE_QUEUES,
     182           &the_message_queue_attributes,
     183           count,
     184           max_message_size,
     185           _Message_queue_MP_Send_extract_proxy ) ) {
     186    if ( is_global )
     187        _Objects_MP_Close(
     188          &_Message_queue_Information, the_message_queue->Object.id);
     189
     190    _Message_queue_Free( the_message_queue );
     191    _Thread_Enable_dispatch();
     192    return RTEMS_TOO_MANY;
     193  }
    217194
    218195  _Objects_Open(
     
    224201  *id = the_message_queue->Object.id;
    225202
    226   if ( _Attributes_Is_global( attribute_set ) )
     203  if ( is_global )
    227204    _Message_queue_MP_Send_process_packet(
    228205      MESSAGE_QUEUE_MP_ANNOUNCE_CREATE,
     
    305282                      &the_message_queue->Object );
    306283
    307       if ( the_message_queue->number_of_pending_messages != 0 )
    308         (void) _Message_queue_Flush_support( the_message_queue );
    309       else
    310         _Thread_queue_Flush(
    311           &the_message_queue->Wait_queue,
    312           _Message_queue_MP_Send_object_was_deleted,
    313           RTEMS_OBJECT_WAS_DELETED
    314         );
     284      _CORE_message_queue_Close(
     285        &the_message_queue->message_queue,
     286        _Message_queue_MP_Send_object_was_deleted,
     287        CORE_MESSAGE_QUEUE_STATUS_WAS_DELETED
     288      );
    315289
    316290      _Message_queue_Free( the_message_queue );
     
    347321 *    id     - pointer to message queue
    348322 *    buffer - pointer to message buffer
     323 *    size   - size of message to sent urgently
    349324 *
    350325 *  Output parameters:
     
    359334)
    360335{
    361   return _Message_queue_Submit(id, buffer, size, MESSAGE_QUEUE_SEND_REQUEST);
     336  return( _Message_queue_Submit(id, buffer, size, MESSAGE_QUEUE_SEND_REQUEST) );
    362337}
    363338
     
    372347 *    id     - pointer to message queue
    373348 *    buffer - pointer to message buffer
     349 *    size   - size of message to sent urgently
    374350 *
    375351 *  Output parameters:
    376352 *    RTEMS_SUCCESSFUL - if successful
    377  *    error code - if unsuccessful
     353 *    error code       - if unsuccessful
    378354 */
    379355
     
    384360)
    385361{
    386   return _Message_queue_Submit(id, buffer, size, MESSAGE_QUEUE_URGENT_REQUEST);
     362  return(_Message_queue_Submit(id, buffer, size, MESSAGE_QUEUE_URGENT_REQUEST));
    387363}
    388364
     
    397373 *    id     - pointer to message queue
    398374 *    buffer - pointer to message buffer
     375 *    size   - size of message to broadcast
    399376 *    count  - pointer to area to store number of threads made ready
    400377 *
    401378 *  Output parameters:
    402379 *    count             - number of threads made ready
    403  *    RTEMS_SUCCESSFUL - if successful
     380 *    RTEMS_SUCCESSFUL  - if successful
    404381 *    error code        - if unsuccessful
    405382 */
     
    414391  register Message_queue_Control *the_message_queue;
    415392  Objects_Locations               location;
    416   Thread_Control                 *the_thread;
    417   unsigned32                      number_broadcasted;
     393  CORE_message_queue_Status       core_status;
    418394
    419395  the_message_queue = _Message_queue_Get( id, &location );
     
    435411
    436412    case OBJECTS_LOCAL:
    437     {
    438       Thread_Wait_information *waitp;
    439       unsigned32 constrained_size;
    440 
    441       number_broadcasted = 0;
    442       while ( (the_thread =
    443                  _Thread_queue_Dequeue(&the_message_queue->Wait_queue)) ) {
    444         waitp = &the_thread->Wait;
    445         number_broadcasted += 1;
    446 
    447         constrained_size = size;
    448         if (size > the_message_queue->maximum_message_size)
    449             constrained_size = the_message_queue->maximum_message_size;
    450 
    451         _Message_queue_Copy_buffer(buffer,
    452                                    waitp->return_argument,
    453                                    constrained_size);
    454 
    455         *(rtems_unsigned32 *)the_thread->Wait.return_argument_1 = size;
    456        
    457         if ( !_Objects_Is_local_id( the_thread->Object.id ) ) {
    458           the_thread->receive_packet->return_code = RTEMS_SUCCESSFUL;
    459 
    460           _Message_queue_MP_Send_response_packet(
    461             MESSAGE_QUEUE_MP_RECEIVE_RESPONSE,
    462             id,
    463             the_thread
    464           );
    465         }
    466       }
     413      core_status = _CORE_message_queue_Broadcast(
     414                      &the_message_queue->message_queue,
     415                      buffer,
     416                      size,
     417                      id,
     418                      _Message_queue_Core_message_queue_mp_support,
     419                      count
     420                    );
     421                     
    467422      _Thread_Enable_dispatch();
    468       *count = number_broadcasted;
    469       return RTEMS_SUCCESSFUL;
    470     }
    471 
    472     default:
    473       return RTEMS_INTERNAL_ERROR;
    474   }
     423      return
     424        _Message_queue_Translate_core_message_queue_return_code( core_status );
     425
     426  }
     427  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
    475428}
    476429
     
    485438 *    id         - queue id
    486439 *    buffer     - pointer to message buffer
     440 *    size       - size of message receive
    487441 *    option_set - options on receive
    488442 *    timeout    - number of ticks to wait
     
    490444 *  Output parameters:
    491445 *    RTEMS_SUCCESSFUL - if successful
    492  *    error code        - if unsuccessful
     446 *    error code       - if unsuccessful
    493447 */
    494448
     
    496450  Objects_Id            id,
    497451  void                 *buffer,
    498   unsigned32           *size_p,
     452  unsigned32           *size,
    499453  unsigned32            option_set,
    500454  rtems_interval        timeout
     
    503457  register Message_queue_Control *the_message_queue;
    504458  Objects_Locations               location;
     459  boolean                         wait;
    505460
    506461  the_message_queue = _Message_queue_Get( id, &location );
     
    515470          id,
    516471          buffer,
    517           size_p,
     472          size,
    518473          option_set,
    519474          timeout
     
    521476
    522477    case OBJECTS_LOCAL:
    523       if ( ! _Message_queue_Seize(the_message_queue,
    524                                   option_set,
    525                                   buffer,
    526                                   size_p))
    527       {
    528         _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
    529       }
     478      if ( _Options_Is_no_wait( option_set ) )
     479        wait = FALSE;
     480      else
     481        wait = TRUE;
     482 
     483      _CORE_message_queue_Seize(
     484        &the_message_queue->message_queue,
     485        the_message_queue->Object.id,
     486        buffer,
     487        size,
     488        wait,
     489        timeout
     490      );
    530491      _Thread_Enable_dispatch();
    531       return _Thread_Executing->Wait.return_code;
     492      return( _Message_queue_Translate_core_message_queue_return_code(
     493                  _Thread_Executing->Wait.return_code ) );
     494
    532495  }
    533496
     
    573536          id,
    574537          0,                               /* buffer not used */
    575           0,                               /* size_p */
     538          0,                               /* size */
    576539          0,                               /* option_set not used */
    577540          MPCI_DEFAULT_TIMEOUT
     
    579542
    580543    case OBJECTS_LOCAL:
    581       if ( the_message_queue->number_of_pending_messages != 0 )
    582         *count = _Message_queue_Flush_support( the_message_queue );
    583       else
    584         *count = 0;
     544      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
    585545      _Thread_Enable_dispatch();
    586546      return RTEMS_SUCCESSFUL;
     
    592552/*PAGE
    593553 *
    594  *  _Message_queue_Seize
    595  *
    596  *  This kernel routine dequeues a message, copies the message buffer to
    597  *  a given destination buffer, and frees the message buffer to the
    598  *  inactive message pool.
    599  *
    600  *  Input parameters:
    601  *    the_message_queue - pointer to message queue
    602  *    option_set        - options on receive
    603  *    the_buffer        - pointer to message buffer to be filled
    604  *
    605  *  Output parameters:
    606  *    TRUE  - if message received or RTEMS_NO_WAIT and no message
    607  *    FALSE - if thread is to block
    608  *
    609  *  NOTE: Dependent on BUFFER_LENGTH
    610  *
    611  *  INTERRUPT LATENCY:
    612  *    available
    613  *    wait
    614  */
    615 
    616 boolean _Message_queue_Seize(
    617   Message_queue_Control  *the_message_queue,
    618   rtems_option            option_set,
    619   void                   *buffer,
    620   unsigned32             *size_p
    621 )
    622 {
    623   ISR_Level                     level;
    624   Message_queue_Buffer_control *the_message;
    625   Thread_Control               *executing;
    626 
    627   executing = _Thread_Executing;
    628   executing->Wait.return_code = RTEMS_SUCCESSFUL;
    629   _ISR_Disable( level );
    630   if ( the_message_queue->number_of_pending_messages != 0 ) {
    631     the_message_queue->number_of_pending_messages -= 1;
    632 
    633     the_message = _Message_queue_Get_pending_message( the_message_queue );
    634     _ISR_Enable( level );
    635     *size_p = the_message->Contents.size;
    636     _Message_queue_Copy_buffer( the_message->Contents.buffer, buffer, *size_p );
    637     _Message_queue_Free_message_buffer(the_message_queue, the_message );
    638     return( TRUE );
    639   }
    640 
    641   if ( _Options_Is_no_wait( option_set ) ) {
    642     _ISR_Enable( level );
    643     executing->Wait.return_code = RTEMS_UNSATISFIED;
    644     return( TRUE );
    645   }
    646 
    647   the_message_queue->Wait_queue.sync = TRUE;
    648   executing->Wait.queue              = &the_message_queue->Wait_queue;
    649   executing->Wait.id                 = the_message_queue->Object.id;
    650   executing->Wait.option             = option_set;
    651   executing->Wait.return_argument    = (void *)buffer;
    652   executing->Wait.return_argument_1  = (void *)size_p;
    653   _ISR_Enable( level );
    654   return FALSE;
    655 }
    656 
    657 /*PAGE
    658  *
    659  *  _Message_queue_Flush_support
    660  *
    661  *  This message manager routine removes all messages from a message queue
    662  *  and returns them to the inactive message pool.
    663  *
    664  *  Input parameters:
    665  *    the_message_queue - pointer to message queue
    666  *
    667  *  Output parameters:
    668  *    returns - number of messages placed on inactive chain
    669  *
    670  *  INTERRUPT LATENCY:
    671  *    only case
    672  */
    673 
    674 unsigned32 _Message_queue_Flush_support(
    675   Message_queue_Control *the_message_queue
    676 )
    677 {
    678   ISR_Level   level;
    679   Chain_Node *inactive_first;
    680   Chain_Node *message_queue_first;
    681   Chain_Node *message_queue_last;
    682   unsigned32  count;
    683 
    684   _ISR_Disable( level );
    685     inactive_first      = the_message_queue->Inactive_messages.first;
    686     message_queue_first = the_message_queue->Pending_messages.first;
    687     message_queue_last  = the_message_queue->Pending_messages.last;
    688 
    689     the_message_queue->Inactive_messages.first = message_queue_first;
    690     message_queue_last->next = inactive_first;
    691     inactive_first->previous = message_queue_last;
    692     message_queue_first->previous          =
    693                _Chain_Head( &the_message_queue->Inactive_messages );
    694 
    695     _Chain_Initialize_empty( &the_message_queue->Pending_messages );
    696 
    697     count = the_message_queue->number_of_pending_messages;
    698     the_message_queue->number_of_pending_messages = 0;
    699   _ISR_Enable( level );
    700   return count;
    701 }
    702 
    703 /*PAGE
    704  *
    705554 *  _Message_queue_Submit
    706555 *
    707  *  This routine implements the directives q_send and q_urgent.  It
    708  *  processes a message that is to be submitted to the designated
    709  *  message queue.  The message will either be processed as a send
    710  *  send message which it will be inserted at the rear of the queue
    711  *  or it will be processed as an urgent message which will be inserted
    712  *  at the front of the queue.
     556 *  This routine implements the directives rtems_message_queue_send
     557 *  and rtems_message_queue_urgent.  It processes a message that is
     558 *  to be submitted to the designated message queue.  The message will
     559 *  either be processed as a send send message which it will be inserted
     560 *  at the rear of the queue or it will be processed as an urgent message
     561 *  which will be inserted at the front of the queue.
    713562 *
    714563 *  Input parameters:
     
    730579)
    731580{
    732   register Message_queue_Control *the_message_queue;
    733   Objects_Locations               location;
    734   Thread_Control                 *the_thread;
    735   Message_queue_Buffer_control   *the_message;
     581  register Message_queue_Control  *the_message_queue;
     582  Objects_Locations                location;
     583  CORE_message_queue_Status        core_status;
    736584
    737585  the_message_queue = _Message_queue_Get( id, &location );
     
    767615
    768616    case OBJECTS_LOCAL:
    769       if (size > the_message_queue->maximum_message_size)
    770       {
    771           _Thread_Enable_dispatch();
    772           return RTEMS_INVALID_SIZE;
    773       }
    774 
    775       /*
    776        * Is there a thread currently waiting on this message queue?
    777        */
    778      
    779       the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
    780       if ( the_thread )
    781       {
    782         _Message_queue_Copy_buffer(
    783           buffer,
    784           the_thread->Wait.return_argument,
    785           size
    786         );
    787         *(rtems_unsigned32 *)the_thread->Wait.return_argument_1 = size;
    788        
    789         if ( !_Objects_Is_local_id( the_thread->Object.id ) ) {
    790           the_thread->receive_packet->return_code = RTEMS_SUCCESSFUL;
    791 
    792           _Message_queue_MP_Send_response_packet(
    793             MESSAGE_QUEUE_MP_RECEIVE_RESPONSE,
    794             id,
    795             the_thread
    796           );
    797 
    798         }
    799         _Thread_Enable_dispatch();
    800         return RTEMS_SUCCESSFUL;
    801       }
    802 
    803       /*
    804        * No one waiting on this one currently.
    805        * Allocate a message buffer and store it away
    806        */
    807 
    808       if ( the_message_queue->number_of_pending_messages ==
    809            the_message_queue->maximum_pending_messages ) {
    810         _Thread_Enable_dispatch();
    811         return RTEMS_TOO_MANY;
    812       }
    813 
    814       the_message = _Message_queue_Allocate_message_buffer(the_message_queue);
    815       if ( the_message == 0) {
    816         _Thread_Enable_dispatch();
    817         return RTEMS_UNSATISFIED;
    818       }
    819 
    820       _Message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size );
    821       the_message->Contents.size = size;
    822      
    823       the_message_queue->number_of_pending_messages += 1;
    824 
    825617      switch ( submit_type ) {
    826618        case MESSAGE_QUEUE_SEND_REQUEST:
    827           _Message_queue_Append( the_message_queue, the_message );
     619          core_status = _CORE_message_queue_Send(
     620                          &the_message_queue->message_queue,
     621                          buffer,
     622                          size,
     623                          id,
     624                          _Message_queue_Core_message_queue_mp_support
     625                        );
    828626          break;
    829627        case MESSAGE_QUEUE_URGENT_REQUEST:
    830           _Message_queue_Prepend( the_message_queue, the_message );
     628          core_status = _CORE_message_queue_Urgent(
     629                          &the_message_queue->message_queue,
     630                          buffer,
     631                          size,
     632                          id,
     633                          _Message_queue_Core_message_queue_mp_support
     634                        );
    831635          break;
     636        default:
     637          core_status = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
     638          return RTEMS_INTERNAL_ERROR;   /* should never get here */
    832639      }
    833640
    834641      _Thread_Enable_dispatch();
     642      return _Message_queue_Translate_core_message_queue_return_code(
     643                core_status );
     644         
     645  }
     646  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
     647}
     648
     649/*PAGE
     650 *
     651 *  _Message_queue_Translate_core_message_queue_return_code
     652 *
     653 *  Input parameters:
     654 *    the_message_queue_status - message_queue status code to translate
     655 *
     656 *  Output parameters:
     657 *    rtems status code - translated RTEMS status code
     658 *
     659 */
     660 
     661rtems_status_code _Message_queue_Translate_core_message_queue_return_code (
     662  unsigned32 the_message_queue_status
     663)
     664{
     665  switch ( the_message_queue_status ) {
     666    case  CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL:
    835667      return RTEMS_SUCCESSFUL;
    836          
    837     default:
    838       return RTEMS_INTERNAL_ERROR;       /* And they were such nice boys, too! */
    839   }
    840 }
     668    case  CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE:
     669      return RTEMS_INVALID_SIZE;
     670    case  CORE_MESSAGE_QUEUE_STATUS_TOO_MANY:
     671      return RTEMS_TOO_MANY;
     672    case CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED:
     673      return RTEMS_UNSATISFIED;
     674    case CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT:
     675      return RTEMS_UNSATISFIED;
     676    case CORE_MESSAGE_QUEUE_STATUS_WAS_DELETED:
     677      return RTEMS_OBJECT_WAS_DELETED;
     678    case CORE_MESSAGE_QUEUE_STATUS_TIMEOUT:
     679      return RTEMS_TIMEOUT;
     680    case THREAD_STATUS_PROXY_BLOCKING:
     681      return THREAD_STATUS_PROXY_BLOCKING;
     682  }
     683  _Internal_error_Occurred(         /* XXX */
     684    INTERNAL_ERROR_RTEMS_API,
     685    TRUE,
     686    the_message_queue_status
     687  );
     688  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
     689}
     690
     691/*PAGE
     692 *
     693 *  _Message_queue_Core_message_queue_mp_support
     694 *
     695 *  Input parameters:
     696 *    the_thread - the remote thread the message was submitted to
     697 *    id         - id of the message queue
     698 *
     699 *  Output parameters: NONE
     700 */
     701 
     702void  _Message_queue_Core_message_queue_mp_support (
     703  Thread_Control *the_thread,
     704  Objects_Id      id
     705)
     706{
     707  the_thread->receive_packet->return_code = RTEMS_SUCCESSFUL;
     708 
     709  _Message_queue_MP_Send_response_packet(
     710    MESSAGE_QUEUE_MP_RECEIVE_RESPONSE,
     711    id,
     712    the_thread
     713  );
     714}
  • cpukit/rtems/src/msgmp.c

    rb3ac6a8d r3652ad35  
    134134      if (buffer) {
    135135          the_packet->Buffer.size = *size_p;
    136           _Message_queue_Copy_buffer(buffer,
    137                                      the_packet->Buffer.buffer,
    138                                      *size_p);
     136          _CORE_message_queue_Copy_buffer(
     137            buffer,
     138            the_packet->Buffer.buffer,
     139            *size_p
     140          );
    139141      }
    140142
     
    311313           the_packet->size;
    312314
    313         _Message_queue_Copy_buffer(
     315        _CORE_message_queue_Copy_buffer(
    314316          the_packet->Buffer.buffer,
    315317          the_thread->Wait.return_argument,
  • cpukit/rtems/src/sem.c

    rb3ac6a8d r3652ad35  
    117117
    118118  if ( !rtems_is_name_valid( name ) )
    119     return ( RTEMS_INVALID_NAME );
     119    return RTEMS_INVALID_NAME;
    120120
    121121  if ( _Attributes_Is_global( attribute_set ) ) {
    122122
    123123    if ( !_System_state_Is_multiprocessing )
    124       return( RTEMS_MP_NOT_CONFIGURED );
     124      return RTEMS_MP_NOT_CONFIGURED;
    125125
    126126    if ( _Attributes_Is_inherit_priority( attribute_set ) )
    127       return( RTEMS_NOT_DEFINED );
     127      return RTEMS_NOT_DEFINED;
    128128
    129129  } else if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
     
    131131    if ( ! ( _Attributes_Is_binary_semaphore( attribute_set ) &&
    132132             _Attributes_Is_priority( attribute_set ) ) )
    133       return( RTEMS_NOT_DEFINED );
     133      return RTEMS_NOT_DEFINED;
    134134
    135135  }
    136136
    137137  if ( _Attributes_Is_binary_semaphore( attribute_set ) && ( count > 1 ) )
    138     return( RTEMS_INVALID_NUMBER );
     138    return RTEMS_INVALID_NUMBER;
    139139
    140140  _Thread_Disable_dispatch();             /* prevents deletion */
     
    144144  if ( !the_semaphore ) {
    145145    _Thread_Enable_dispatch();
    146     return( RTEMS_TOO_MANY );
     146    return RTEMS_TOO_MANY;
    147147  }
    148148
     
    152152    _Semaphore_Free( the_semaphore );
    153153    _Thread_Enable_dispatch();
    154     return( RTEMS_TOO_MANY );
     154    return RTEMS_TOO_MANY;
    155155  }
    156156
     
    211211    );
    212212  _Thread_Enable_dispatch();
    213   return( RTEMS_SUCCESSFUL );
     213  return RTEMS_SUCCESSFUL;
    214214}
    215215
     
    271271  switch ( location ) {
    272272    case OBJECTS_ERROR:
    273       return( RTEMS_INVALID_ID );
     273      return RTEMS_INVALID_ID;
    274274    case OBJECTS_REMOTE:
    275275      _Thread_Dispatch();
    276       return( RTEMS_ILLEGAL_ON_REMOTE_OBJECT );
     276      return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
    277277    case OBJECTS_LOCAL:
    278278      if ( _Attributes_Is_binary_semaphore( the_semaphore->attribute_set) ) {
    279279        if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) ) {
    280280          _Thread_Enable_dispatch();
    281           return( RTEMS_RESOURCE_IN_USE );
     281          return RTEMS_RESOURCE_IN_USE;
    282282        }
    283283        else
     
    311311      }
    312312      _Thread_Enable_dispatch();
    313       return( RTEMS_SUCCESSFUL );
    314   }
    315 
    316   return( RTEMS_INTERNAL_ERROR );   /* unreached - only to remove warnings */
     313      return RTEMS_SUCCESSFUL;
     314  }
     315
     316  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
    317317}
    318318
     
    346346  switch ( location ) {
    347347    case OBJECTS_ERROR:
    348       return( RTEMS_INVALID_ID );
     348      return RTEMS_INVALID_ID;
    349349    case OBJECTS_REMOTE:
    350350      return _Semaphore_MP_Send_request_packet(
     
    368368        );
    369369        _Thread_Enable_dispatch();
    370         return( _Semaphore_Translate_core_mutex_return_code(
    371                   _Thread_Executing->Wait.return_code ) );
     370        return _Semaphore_Translate_core_mutex_return_code(
     371                  _Thread_Executing->Wait.return_code );
    372372      } else {
    373373        _CORE_semaphore_Seize(
     
    378378        );
    379379        _Thread_Enable_dispatch();
    380         return( _Semaphore_Translate_core_semaphore_return_code(
    381                   _Thread_Executing->Wait.return_code ) );
     380        return _Semaphore_Translate_core_semaphore_return_code(
     381                  _Thread_Executing->Wait.return_code );
    382382      }
    383383  }
    384384
    385   return( RTEMS_INTERNAL_ERROR );   /* unreached - only to remove warnings */
     385  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
    386386}
    387387
     
    412412  switch ( location ) {
    413413    case OBJECTS_ERROR:
    414       return( RTEMS_INVALID_ID );
     414      return RTEMS_INVALID_ID;
    415415    case OBJECTS_REMOTE:
    416       return(
    417         _Semaphore_MP_Send_request_packet(
    418           SEMAPHORE_MP_RELEASE_REQUEST,
    419           id,
    420           0,                               /* Not used */
    421           MPCI_DEFAULT_TIMEOUT
    422         )
     416      return _Semaphore_MP_Send_request_packet(
     417        SEMAPHORE_MP_RELEASE_REQUEST,
     418        id,
     419        0,                               /* Not used */
     420        MPCI_DEFAULT_TIMEOUT
    423421      );
    424422    case OBJECTS_LOCAL:
     
    430428                       );
    431429        _Thread_Enable_dispatch();
    432         return( _Semaphore_Translate_core_mutex_return_code( mutex_status ) );
     430        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
    433431      }
    434432      else
     
    439437                           );
    440438        _Thread_Enable_dispatch();
    441         return(
    442           _Semaphore_Translate_core_semaphore_return_code( semaphore_status ) );
    443   }
    444 
    445   return( RTEMS_INTERNAL_ERROR );   /* unreached - only to remove warnings */
     439        return
     440          _Semaphore_Translate_core_semaphore_return_code( semaphore_status );
     441  }
     442
     443  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
    446444}
    447445
     
    464462  switch ( the_mutex_status ) {
    465463    case  CORE_MUTEX_STATUS_SUCCESSFUL:
    466       return( RTEMS_SUCCESSFUL );
     464      return RTEMS_SUCCESSFUL;
    467465    case CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT:
    468       return( RTEMS_UNSATISFIED );
     466      return RTEMS_UNSATISFIED;
    469467    case CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED:
    470       return( RTEMS_INTERNAL_ERROR );
     468      return RTEMS_INTERNAL_ERROR;
    471469    case CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE:
    472       return( RTEMS_NOT_OWNER_OF_RESOURCE );
     470      return RTEMS_NOT_OWNER_OF_RESOURCE;
    473471    case CORE_MUTEX_WAS_DELETED:
    474       return( RTEMS_OBJECT_WAS_DELETED );
     472      return RTEMS_OBJECT_WAS_DELETED;
    475473    case CORE_MUTEX_TIMEOUT:
    476       return( RTEMS_TIMEOUT );
     474      return RTEMS_TIMEOUT;
    477475    case THREAD_STATUS_PROXY_BLOCKING:
    478       return( THREAD_STATUS_PROXY_BLOCKING );
    479   }
    480   _Internal_error_Occurred(
    481     INTERNAL_ERROR_RTEMS_API,
    482     TRUE,
    483     the_mutex_status
    484   );
    485   return( RTEMS_INTERNAL_ERROR );   /* unreached - only to remove warnings */
     476      return THREAD_STATUS_PROXY_BLOCKING;
     477  }
     478  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
    486479}
    487480
     
    504497  switch ( the_semaphore_status ) {
    505498    case  CORE_SEMAPHORE_STATUS_SUCCESSFUL:
    506       return( RTEMS_SUCCESSFUL );
     499      return RTEMS_SUCCESSFUL;
    507500    case CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT:
    508       return( RTEMS_UNSATISFIED );
     501      return RTEMS_UNSATISFIED;
    509502    case CORE_SEMAPHORE_WAS_DELETED:
    510       return( RTEMS_OBJECT_WAS_DELETED );
     503      return RTEMS_OBJECT_WAS_DELETED;
    511504    case CORE_SEMAPHORE_TIMEOUT:
    512       return( RTEMS_TIMEOUT );
     505      return RTEMS_TIMEOUT;
    513506    case THREAD_STATUS_PROXY_BLOCKING:
    514       return( THREAD_STATUS_PROXY_BLOCKING );
    515   }
    516   _Internal_error_Occurred(
    517     INTERNAL_ERROR_RTEMS_API,
    518     TRUE,
    519     the_semaphore_status
    520   );
    521   return( RTEMS_INTERNAL_ERROR );   /* unreached - only to remove warnings */
    522   return( RTEMS_INTERNAL_ERROR );   /* unreached - only to remove warnings */
     507      return THREAD_STATUS_PROXY_BLOCKING;
     508  }
     509  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
    523510}
    524511
  • cpukit/rtems/src/tasks.c

    rb3ac6a8d r3652ad35  
    115115 
    116116  _ISR_Disable( level );
    117 
    118   signal_set = asr->signals_posted;
    119  
    120   if ( signal_set ) {
    121   /* if ( _ASR_Are_signals_pending( asr ) ) {
    122  
    123     signal_set          = asr->signals_posted; */
     117    signal_set = asr->signals_posted;
    124118    asr->signals_posted = 0;
    125     _ISR_Enable( level );
    126  
    127     asr->nest_level += 1;
    128     rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
    129  
    130     (*asr->handler)( signal_set );
    131  
    132     asr->nest_level -= 1;
    133     rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
    134   }
    135   else
    136     _ISR_Enable( level );
     119  _ISR_Enable( level );
     120 
     121 
     122  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
     123    return;
     124 
     125  asr->nest_level += 1;
     126  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
     127 
     128  (*asr->handler)( signal_set );
     129
     130  asr->nest_level -= 1;
     131  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
    137132
    138133}
Note: See TracChangeset for help on using the changeset viewer.