コード例 #1
0
ファイル: sempost.c プロジェクト: aniwang2013/leon-rtems
int sem_post(
  sem_t  *sem
)
{
  register POSIX_Semaphore_Control *the_semaphore;
  Objects_Locations                 location;

  the_semaphore = _POSIX_Semaphore_Get( sem, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      _CORE_semaphore_Surrender(
        &the_semaphore->Semaphore,
        the_semaphore->Object.id,
#if defined(RTEMS_MULTIPROCESSING)
        NULL         /* XXX need to define a routine to handle this case */
#else
        NULL
#endif
      );
      _Thread_Enable_dispatch();
      return 0;

#if defined(RTEMS_MULTIPROCESSING)
    case OBJECTS_REMOTE:
#endif
    case OBJECTS_ERROR:
      break;
  }

  rtems_set_errno_and_return_minus_one( EINVAL );
}
コード例 #2
0
ファイル: sempost.c プロジェクト: cloud-hot/rtems
int sem_post(
  sem_t  *sem
)
{
  POSIX_Semaphore_Control          *the_semaphore;
  Objects_Locations                 location;

  the_semaphore = _POSIX_Semaphore_Get( sem, &location );
  switch ( location ) {

    case OBJECTS_LOCAL:
      _CORE_semaphore_Surrender(
        &the_semaphore->Semaphore,
        the_semaphore->Object.id,
#if defined(RTEMS_MULTIPROCESSING)
        NULL         /* POSIX Semaphores are local only */
#else
        NULL
#endif
      );
      _Objects_Put( &the_semaphore->Object );
      return 0;

#if defined(RTEMS_MULTIPROCESSING)
    case OBJECTS_REMOTE:
#endif
    case OBJECTS_ERROR:
      break;
  }

  rtems_set_errno_and_return_minus_one( EINVAL );
}
コード例 #3
0
ファイル: mpci.c プロジェクト: 0871087123/rtems
void _MPCI_Announce ( void )
{
  _Thread_Disable_dispatch();
  (void) _CORE_semaphore_Surrender( &_MPCI_Semaphore, 0, 0 );
  _Thread_Enable_dispatch();
}
コード例 #4
0
ファイル: semrelease.c プロジェクト: Dipupo/rtems
rtems_status_code rtems_semaphore_release(
  rtems_id   id
)
{
  Semaphore_Control          *the_semaphore;
  Objects_Locations           location;
  CORE_mutex_Status           mutex_status;
  CORE_semaphore_Status       semaphore_status;
  rtems_attribute             attribute_set;
  ISR_lock_Context            lock_context;

  the_semaphore = _Semaphore_Get_interrupt_disable(
    id,
    &location,
    &lock_context
  );
  switch ( location ) {

    case OBJECTS_LOCAL:
      attribute_set = the_semaphore->attribute_set;
#if defined(RTEMS_SMP)
      if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
        MRSP_Status mrsp_status;

        mrsp_status = _MRSP_Surrender(
          &the_semaphore->Core_control.mrsp,
          _Thread_Executing,
          &lock_context
        );
        return _Semaphore_Translate_MRSP_status_code( mrsp_status );
      } else
#endif
      if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
        mutex_status = _CORE_mutex_Surrender(
          &the_semaphore->Core_control.mutex,
          _Semaphore_Core_mutex_mp_support,
          id,
          &lock_context
        );
        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
      } else {
        semaphore_status = _CORE_semaphore_Surrender(
          &the_semaphore->Core_control.semaphore,
          _Semaphore_Core_mutex_mp_support,
          id,
          &lock_context
        );
        return
          _Semaphore_Translate_core_semaphore_return_code( semaphore_status );
      }

#if defined(RTEMS_MULTIPROCESSING)
    case OBJECTS_REMOTE:
      return _Semaphore_MP_Send_request_packet(
        SEMAPHORE_MP_RELEASE_REQUEST,
        id,
        0,                               /* Not used */
        MPCI_DEFAULT_TIMEOUT
      );
#endif

    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
コード例 #5
0
ファイル: semrelease.c プロジェクト: vecnatechnologies/rtems
rtems_status_code rtems_semaphore_release( rtems_id id )
{
    Semaphore_Control    *the_semaphore;
    Thread_queue_Context  queue_context;
    Thread_Control       *executing;
    Status_Control        status;

    the_semaphore = _Semaphore_Get( id, &queue_context );

    if ( the_semaphore == NULL ) {
#if defined(RTEMS_MULTIPROCESSING)
        return _Semaphore_MP_Release( id );
#else
        return RTEMS_INVALID_ID;
#endif
    }

    executing = _Thread_Executing;

    _Thread_queue_Context_set_MP_callout(
        &queue_context,
        _Semaphore_Core_mutex_mp_support
    );

    switch ( the_semaphore->variant ) {
    case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY:
        status = _CORE_recursive_mutex_Surrender(
                     &the_semaphore->Core_control.Mutex.Recursive,
                     executing,
                     &queue_context
                 );
        break;
    case SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING:
        status = _CORE_ceiling_mutex_Surrender(
                     &the_semaphore->Core_control.Mutex,
                     executing,
                     &queue_context
                 );
        break;
    case SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL:
        _CORE_recursive_mutex_Surrender_no_protocol(
            &the_semaphore->Core_control.Mutex.Recursive,
            _Semaphore_Get_operations( the_semaphore ),
            executing,
            &queue_context
        );
        status = STATUS_SUCCESSFUL;
        break;
    case SEMAPHORE_VARIANT_SIMPLE_BINARY:
        status = _CORE_semaphore_Surrender(
                     &the_semaphore->Core_control.Semaphore,
                     _Semaphore_Get_operations( the_semaphore ),
                     1,
                     &queue_context
                 );
        _Assert(
            status == STATUS_SUCCESSFUL
            || status == STATUS_MAXIMUM_COUNT_EXCEEDED
        );
        status = STATUS_SUCCESSFUL;
        break;
#if defined(RTEMS_SMP)
    case SEMAPHORE_VARIANT_MRSP:
        status = _MRSP_Surrender(
                     &the_semaphore->Core_control.MRSP,
                     executing,
                     &queue_context
                 );
        break;
#endif
    default:
        _Assert( the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING );
        status = _CORE_semaphore_Surrender(
                     &the_semaphore->Core_control.Semaphore,
                     _Semaphore_Get_operations( the_semaphore ),
                     UINT32_MAX,
                     &queue_context
                 );
        break;
    }

    return _Status_Get( status );
}