void _RTEMS_tasks_MP_Process_packet (
rtems_packet_prefix *the_packet_prefix
)
{
RTEMS_tasks_MP_Packet *the_packet;
Thread_Control *the_thread;
bool ignored;
the_packet = (RTEMS_tasks_MP_Packet *) the_packet_prefix;
switch ( the_packet->operation ) {
case RTEMS_TASKS_MP_ANNOUNCE_CREATE:
ignored = _Objects_MP_Allocate_and_open(
&_RTEMS_tasks_Information.Objects,
the_packet->name,
the_packet->Prefix.id,
true
);
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_ANNOUNCE_DELETE:
_Objects_MP_Close(
&_RTEMS_tasks_Information.Objects,
the_packet->Prefix.id
);
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_SUSPEND_REQUEST:
the_packet->Prefix.return_code = rtems_task_suspend(
the_packet->Prefix.id
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_SUSPEND_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_SUSPEND_RESPONSE:
case RTEMS_TASKS_MP_RESUME_RESPONSE:
case RTEMS_TASKS_MP_SET_NOTE_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_RESUME_REQUEST:
the_packet->Prefix.return_code = rtems_task_resume(
the_packet->Prefix.id
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_RESUME_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_SET_PRIORITY_REQUEST:
the_packet->Prefix.return_code = rtems_task_set_priority(
the_packet->Prefix.id,
the_packet->the_priority,
&the_packet->the_priority
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_SET_PRIORITY_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_SET_PRIORITY_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
*(rtems_task_priority *)the_thread->Wait.return_argument =
the_packet->the_priority;
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_GET_NOTE_REQUEST:
the_packet->Prefix.return_code = rtems_task_get_note(
the_packet->Prefix.id,
the_packet->notepad,
&the_packet->note
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_GET_NOTE_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_GET_NOTE_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
*(uint32_t *)the_thread->Wait.return_argument = the_packet->note;
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_SET_NOTE_REQUEST:
the_packet->Prefix.return_code = rtems_task_set_note(
the_packet->Prefix.id,
the_packet->notepad,
the_packet->note
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_SET_NOTE_RESPONSE,
_Thread_Executing
);
break;
}
}
void _Partition_MP_Process_packet (
rtems_packet_prefix *the_packet_prefix
)
{
Partition_MP_Packet *the_packet;
Thread_Control *the_thread;
the_packet = (Partition_MP_Packet *) the_packet_prefix;
switch ( the_packet->operation ) {
case PARTITION_MP_ANNOUNCE_CREATE:
_Objects_MP_Allocate_and_open(
&_Partition_Information,
the_packet->name,
the_packet->Prefix.id,
true
);
_MPCI_Return_packet( the_packet_prefix );
break;
case PARTITION_MP_ANNOUNCE_DELETE:
_Objects_MP_Close( &_Partition_Information, the_packet->Prefix.id );
_MPCI_Return_packet( the_packet_prefix );
break;
case PARTITION_MP_EXTRACT_PROXY:
the_thread = _Thread_MP_Find_proxy( the_packet->proxy_id );
if ( ! _Thread_Is_null( the_thread ) )
_Thread_queue_Extract( the_thread );
_MPCI_Return_packet( the_packet_prefix );
break;
case PARTITION_MP_GET_BUFFER_REQUEST:
the_packet->Prefix.return_code = rtems_partition_get_buffer(
the_packet->Prefix.id,
&the_packet->buffer
);
_Partition_MP_Send_response_packet(
PARTITION_MP_GET_BUFFER_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
case PARTITION_MP_GET_BUFFER_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
*(void **)the_thread->Wait.return_argument = the_packet->buffer;
_MPCI_Return_packet( the_packet_prefix );
break;
case PARTITION_MP_RETURN_BUFFER_REQUEST:
the_packet->Prefix.return_code = rtems_partition_return_buffer(
the_packet->Prefix.id,
the_packet->buffer
);
_Partition_MP_Send_response_packet(
PARTITION_MP_RETURN_BUFFER_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
case PARTITION_MP_RETURN_BUFFER_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
_MPCI_Return_packet( the_packet_prefix );
break;
}
}
void _Message_queue_MP_Process_packet (
rtems_packet_prefix *the_packet_prefix
)
{
Message_queue_MP_Packet *the_packet;
Thread_Control *the_thread;
bool ignored;
the_packet = (Message_queue_MP_Packet *) the_packet_prefix;
switch ( the_packet->operation ) {
case MESSAGE_QUEUE_MP_ANNOUNCE_CREATE:
ignored = _Objects_MP_Allocate_and_open(
&_Message_queue_Information,
the_packet->name,
the_packet->Prefix.id,
true
);
_MPCI_Return_packet( the_packet_prefix );
break;
case MESSAGE_QUEUE_MP_ANNOUNCE_DELETE:
_Objects_MP_Close( &_Message_queue_Information, the_packet->Prefix.id );
_MPCI_Return_packet( the_packet_prefix );
break;
case MESSAGE_QUEUE_MP_EXTRACT_PROXY:
the_thread = _Thread_MP_Find_proxy( the_packet->proxy_id );
if (! _Thread_Is_null( the_thread ) )
_Thread_queue_Extract( the_thread );
_MPCI_Return_packet( the_packet_prefix );
break;
case MESSAGE_QUEUE_MP_RECEIVE_REQUEST:
the_packet->Prefix.return_code = rtems_message_queue_receive(
the_packet->Prefix.id,
the_packet->Buffer.buffer,
&the_packet->size,
the_packet->option_set,
the_packet->Prefix.timeout
);
if ( the_packet->Prefix.return_code != RTEMS_PROXY_BLOCKING )
_Message_queue_MP_Send_response_packet(
MESSAGE_QUEUE_MP_RECEIVE_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
case MESSAGE_QUEUE_MP_RECEIVE_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
if (the_packet->Prefix.return_code == RTEMS_SUCCESSFUL) {
*(size_t *) the_thread->Wait.return_argument =
the_packet->size;
_CORE_message_queue_Copy_buffer(
the_packet->Buffer.buffer,
the_thread->Wait.return_argument_second.mutable_object,
the_packet->size
);
}
_MPCI_Return_packet( the_packet_prefix );
break;
case MESSAGE_QUEUE_MP_SEND_REQUEST:
the_packet->Prefix.return_code = rtems_message_queue_send(
the_packet->Prefix.id,
the_packet->Buffer.buffer,
the_packet->Buffer.size
);
_Message_queue_MP_Send_response_packet(
MESSAGE_QUEUE_MP_SEND_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
case MESSAGE_QUEUE_MP_SEND_RESPONSE:
case MESSAGE_QUEUE_MP_URGENT_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
_MPCI_Return_packet( the_packet_prefix );
break;
case MESSAGE_QUEUE_MP_URGENT_REQUEST:
the_packet->Prefix.return_code = rtems_message_queue_urgent(
the_packet->Prefix.id,
the_packet->Buffer.buffer,
the_packet->Buffer.size
);
_Message_queue_MP_Send_response_packet(
MESSAGE_QUEUE_MP_URGENT_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
case MESSAGE_QUEUE_MP_BROADCAST_REQUEST:
the_packet->Prefix.return_code = rtems_message_queue_broadcast(
the_packet->Prefix.id,
the_packet->Buffer.buffer,
the_packet->Buffer.size,
&the_packet->count
);
_Message_queue_MP_Send_response_packet(
MESSAGE_QUEUE_MP_BROADCAST_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
case MESSAGE_QUEUE_MP_BROADCAST_RESPONSE:
case MESSAGE_QUEUE_MP_FLUSH_RESPONSE:
case MESSAGE_QUEUE_MP_GET_NUMBER_PENDING_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
*(uint32_t *) the_thread->Wait.return_argument = the_packet->count;
_MPCI_Return_packet( the_packet_prefix );
break;
case MESSAGE_QUEUE_MP_FLUSH_REQUEST:
the_packet->Prefix.return_code = rtems_message_queue_flush(
the_packet->Prefix.id,
&the_packet->count
);
_Message_queue_MP_Send_response_packet(
MESSAGE_QUEUE_MP_FLUSH_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
case MESSAGE_QUEUE_MP_GET_NUMBER_PENDING_REQUEST:
the_packet->Prefix.return_code = rtems_message_queue_get_number_pending(
the_packet->Prefix.id,
&the_packet->count
);
_Message_queue_MP_Send_response_packet(
MESSAGE_QUEUE_MP_GET_NUMBER_PENDING_RESPONSE,
the_packet->Prefix.id,
_Thread_Executing
);
break;
}
}
int _POSIX_Message_queue_Create_support(
const char *name,
int pshared,
unsigned int oflag,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
POSIX_Message_queue_Control *the_mq;
CORE_message_queue_Attributes *the_mq_attr;
struct mq_attr attr;
_Thread_Disable_dispatch();
/*
* There is no real basis for the default values. They will work
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg < 0 ){
_Thread_Enable_dispatch();
set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize < 0 ){
_Thread_Enable_dispatch();
set_errno_and_return_minus_one( EINVAL );
}
attr = *attr_ptr;
}
#if 0 && defined(RTEMS_MULTIPROCESSING)
if ( pshared == PTHREAD_PROCESS_SHARED &&
!( _Objects_MP_Allocate_and_open( &_POSIX_Message_queue_Information, 0,
the_mq->Object.id, FALSE ) ) ) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
set_errno_and_return_minus_one( ENFILE );
}
#endif
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
the_mq->oflag = oflag;
the_mq->named = TRUE;
the_mq->open_count = 1;
the_mq->linked = TRUE;
/* XXX
*
* Note that thread blocking discipline should be based on the
* current scheduling policy.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
&the_mq->Message_queue,
OBJECTS_POSIX_MESSAGE_QUEUES,
the_mq_attr,
attr.mq_maxmsg,
attr.mq_msgsize,
#if 0 && defined(RTEMS_MULTIPROCESSING)
_POSIX_Message_queue_MP_Send_extract_proxy
#else
NULL
#endif
) ) {
#if 0 && defined(RTEMS_MULTIPROCESSING)
if ( pshared == PTHREAD_PROCESS_SHARED )
_Objects_MP_Close( &_POSIX_Message_queue_Information, the_mq->Object.id );
#endif
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
set_errno_and_return_minus_one( ENOSPC );
}
_Objects_Open(
&_POSIX_Message_queue_Information,
&the_mq->Object,
(char *) name
);
*message_queue = the_mq;
#if 0 && defined(RTEMS_MULTIPROCESSING)
if ( pshared == PTHREAD_PROCESS_SHARED )
_POSIX_Message_queue_MP_Send_process_packet(
POSIX_MESSAGE_QUEUE_MP_ANNOUNCE_CREATE,
the_mq->Object.id,
(char *) name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return 0;
}
rtems_status_code rtems_partition_create(
rtems_name name,
void *starting_address,
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) &&
!( _Objects_MP_Allocate_and_open( &_Partition_Information, name,
the_partition->Object.id, false ) ) ) {
_Partition_Free( the_partition );
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
_Objects_Open(
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) )
_Partition_MP_Send_process_packet(
PARTITION_MP_ANNOUNCE_CREATE,
the_partition->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
epos_status_code epos_message_queue_create(
epos_name name,
uint32_t count,
size_t max_message_size,
epos_attribute attribute_set,
epos_id *id
)
{
register Message_queue_Control *the_message_queue;
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !epos_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
#if defined(RTEMS_MULTIPROCESSING)
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
return RTEMS_INVALID_SIZE;
#if defined(RTEMS_MULTIPROCESSING)
#if 1
/*
* I am not 100% sure this should be an error.
* It seems reasonable to create a que with a large max size,
* and then just send smaller msgs from remote (or all) nodes.
*/
if ( is_global && (_MPCI_table->maximum_packet_size < max_message_size) )
return RTEMS_INVALID_SIZE;
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global &&
!( _Objects_MP_Allocate_and_open( &_Message_queue_Information,
name, the_message_queue->Object.id, false ) ) ) {
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
&the_message_queue->message_queue,
&the_msgq_attributes,
count,
max_message_size
) ) {
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
return RTEMS_UNSATISFIED;
}
_Objects_Open(
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Message_queue_MP_Send_process_packet(
MESSAGE_QUEUE_MP_ANNOUNCE_CREATE,
the_message_queue->Object.id,
name,
0
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_semaphore_create(
rtems_name name,
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) ) {
if ( !_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) &&
! ( _Objects_MP_Allocate_and_open( &_Semaphore_Information, name,
the_semaphore->Object.id, false ) ) ) {
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
else
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
&the_semaphore->Core_control.semaphore,
&the_semaphore_attr,
count
);
} else {
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
the_mutex_attr.only_owner_release = false;
}
mutex_status = _CORE_mutex_Initialize(
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
return RTEMS_INVALID_PRIORITY;
}
}
/*
* Whether we initialized it as a mutex or counting semaphore, it is
* now ready to be "offered" for use as a Classic API Semaphore.
*/
_Objects_Open(
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) )
_Semaphore_MP_Send_process_packet(
SEMAPHORE_MP_ANNOUNCE_CREATE,
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_semaphore_create(
rtems_name name,
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) ) {
if ( !_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ||
_Attributes_Is_multiprocessor_resource_sharing( attribute_set ) )
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) &&
!( _Attributes_Is_binary_semaphore( attribute_set ) &&
!_Attributes_Is_priority( attribute_set ) ) ) {
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( !_Attributes_Has_at_most_one_protocol( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
return RTEMS_INVALID_NUMBER;
#if !defined(RTEMS_SMP)
/*
* On uni-processor configurations the Multiprocessor Resource Sharing
* Protocol is equivalent to the Priority Ceiling Protocol.
*/
if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
attribute_set |= RTEMS_PRIORITY_CEILING | RTEMS_PRIORITY;
}
#endif
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Objects_Allocator_unlock();
return RTEMS_TOO_MANY;
}
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) &&
! ( _Objects_MP_Allocate_and_open( &_Semaphore_Information, name,
the_semaphore->Object.id, false ) ) ) {
_Semaphore_Free( the_semaphore );
_Objects_Allocator_unlock();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
else
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
&the_semaphore->Core_control.semaphore,
&the_semaphore_attr,
count
);
#if defined(RTEMS_SMP)
} else if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
MRSP_Status mrsp_status = _MRSP_Initialize(
&the_semaphore->Core_control.mrsp,
priority_ceiling,
_Thread_Get_executing(),
count != 1
);
if ( mrsp_status != MRSP_SUCCESSFUL ) {
_Semaphore_Free( the_semaphore );
_Objects_Allocator_unlock();
return _Semaphore_Translate_MRSP_status_code( mrsp_status );
}
#endif
} else {
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = _RTEMS_tasks_Priority_to_Core(
priority_ceiling
);
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
the_mutex_attr.only_owner_release = false;
}
mutex_status = _CORE_mutex_Initialize(
&the_semaphore->Core_control.mutex,
_Thread_Get_executing(),
&the_mutex_attr,
count != 1
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
_Semaphore_Free( the_semaphore );
_Objects_Allocator_unlock();
return RTEMS_INVALID_PRIORITY;
}
}
/*
* Whether we initialized it as a mutex or counting semaphore, it is
* now ready to be "offered" for use as a Classic API Semaphore.
*/
_Objects_Open(
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
#if defined(RTEMS_MULTIPROCESSING)
if ( _Attributes_Is_global( attribute_set ) )
_Semaphore_MP_Send_process_packet(
SEMAPHORE_MP_ANNOUNCE_CREATE,
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
}
