ER rsm_tsk(
ID tskid
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _ITRON_Task_Get( tskid, &location );
switch ( location ) {
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
return _ITRON_Task_Clarify_get_id_error( tskid );
case OBJECTS_LOCAL:
if ( _Thread_Is_executing( the_thread ) )
_ITRON_return_errorno( E_OBJ );
if ( _States_Is_dormant( the_thread->current_state ))
_ITRON_return_errorno( E_OBJ );
if ( ! _States_Is_suspended(the_thread->current_state) )
_ITRON_return_errorno( E_OBJ );
_Thread_Resume( the_thread, false );
break;
}
_ITRON_return_errorno( E_OK );
}
ER cre_mbx(
ID mbxid,
T_CMBX *pk_cmbx
)
{
register ITRON_Mailbox_Control *the_mailbox;
CORE_message_queue_Attributes the_mailbox_attributes;
if ( !pk_cmbx )
return E_PAR;
if ((pk_cmbx->mbxatr & (TA_TPRI | TA_MPRI)) != 0 )
return E_RSATR;
_Thread_Disable_dispatch(); /* protects object pointer */
the_mailbox = _ITRON_Mailbox_Allocate( mbxid );
if ( !the_mailbox ) {
_Thread_Enable_dispatch();
return _ITRON_Mailbox_Clarify_allocation_id_error( mbxid );
}
the_mailbox->count = pk_cmbx->bufcnt;
if (pk_cmbx->mbxatr & TA_MPRI)
the_mailbox->do_message_priority = TRUE;
else
the_mailbox->do_message_priority = FALSE;
if (pk_cmbx->mbxatr & TA_TPRI)
the_mailbox_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
else
the_mailbox_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( !_CORE_message_queue_Initialize(
&the_mailbox->message_queue,
OBJECTS_ITRON_MAILBOXES,
&the_mailbox_attributes,
the_mailbox->count,
sizeof(T_MSG *),
NULL ) ) { /* Multiprocessing not supported */
_ITRON_Mailbox_Free(the_mailbox);
_ITRON_return_errorno( E_OBJ );
}
_ITRON_Objects_Open( &_ITRON_Mailbox_Information, &the_mailbox->Object );
/*
* If multiprocessing were supported, this is where we would announce
* the existence of the semaphore to the rest of the system.
*/
#if defined(RTEMS_MULTIPROCESSING)
#endif
_ITRON_return_errorno( E_OK );
}
ER rel_wai(
ID tskid
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _ITRON_Task_Get( tskid, &location );
switch ( location ) {
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
return _ITRON_Task_Clarify_get_id_error( tskid );
case OBJECTS_LOCAL:
/*
* XXX - FILL ME IN.
*/
break;
}
_ITRON_return_errorno( E_OK );
}
ER del_mbx(
ID mbxid
)
{
register ITRON_Mailbox_Control *the_mailbox;
Objects_Locations location;
the_mailbox= _ITRON_Mailbox_Get( mbxid, &location );
switch ( location ) {
case OBJECTS_ERROR:
case OBJECTS_REMOTE:
return _ITRON_Mailbox_Clarify_get_id_error( mbxid );
case OBJECTS_LOCAL:
_Objects_Close( &_ITRON_Mailbox_Information, &the_mailbox->Object );
_CORE_message_queue_Close(
&the_mailbox->message_queue,
NULL, /* Multiprocessing not supported */
CORE_MESSAGE_QUEUE_STATUS_WAS_DELETED
);
_ITRON_Mailbox_Free(the_mailbox);
break;
}
_ITRON_return_errorno( E_OK );
}
ER chg_pri(
ID tskid,
PRI tskpri
)
{
register Thread_Control *the_thread;
Objects_Locations location;
Priority_Control new_priority;
the_thread = _ITRON_Task_Get( tskid, &location );
switch ( location ) {
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
return _ITRON_Task_Clarify_get_id_error( tskid );
case OBJECTS_LOCAL:
if (_States_Is_dormant( the_thread->current_state ))
_ITRON_return_errorno( E_OBJ );
if (( tskpri <= 0 ) || ( tskpri >= PRIORITY_MAXIMUM-1 ))
_ITRON_return_errorno( E_PAR );
new_priority = _ITRON_Task_Priority_to_Core( tskpri );
the_thread->real_priority = new_priority;
/*
* The priority should not be changed until later if priority
* inheratance has occured.
*/
if ( the_thread->resource_count == 0 ||
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
break;
}
_ITRON_return_errorno( E_OK );
}
ER trcv_msg(
T_MSG **ppk_msg,
ID mbxid,
TMO tmout
)
{
register ITRON_Mailbox_Control *the_mailbox;
Watchdog_Interval interval;
bool wait;
Objects_Locations location;
size_t size;
if (!ppk_msg)
return E_PAR;
interval = 0;
if ( tmout == TMO_POL ) {
wait = false;
} else {
wait = true;
if ( tmout != TMO_FEVR )
interval = TOD_MILLISECONDS_TO_TICKS(tmout);
}
if ( wait && _ITRON_Is_in_non_task_state() )
return E_CTX;
the_mailbox = _ITRON_Mailbox_Get( mbxid, &location );
switch ( location ) {
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
return _ITRON_Mailbox_Clarify_get_id_error( mbxid );
case OBJECTS_LOCAL:
_CORE_message_queue_Seize(
&the_mailbox->message_queue,
the_mailbox->Object.id,
ppk_msg,
&size,
wait,
interval
);
break;
}
_ITRON_return_errorno(
_ITRON_Mailbox_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code ) );
}
ER ref_mbx(
T_RMBX *pk_rmbx,
ID mbxid
)
{
register ITRON_Mailbox_Control *the_mailbox;
Objects_Locations location;
Chain_Control *pending;
if ( !pk_rmbx )
return E_PAR;
the_mailbox = _ITRON_Mailbox_Get( mbxid, &location );
switch ( location ) {
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
return _ITRON_Mailbox_Clarify_get_id_error( mbxid );
case OBJECTS_LOCAL:
pending = &the_mailbox->message_queue.Pending_messages;
if ( _Chain_Is_empty( pending ) )
pk_rmbx->pk_msg = NULL;
else
pk_rmbx->pk_msg = (T_MSG *) pending->first;
/*
* Fill in whether or not there is a waiting task
*/
if ( !_Thread_queue_First( &the_mailbox->message_queue.Wait_queue ) )
pk_rmbx->wtsk = FALSE;
else
pk_rmbx->wtsk = TRUE;
break;
}
_ITRON_return_errorno( E_OK );
}
ER ref_tsk(
T_RTSK *pk_rtsk,
ID tskid
)
{
register Thread_Control *the_thread;
Objects_Locations location;
Priority_Control core_priority;
if (!pk_rtsk)
return E_PAR;
the_thread = _ITRON_Task_Get( tskid, &location );
switch ( location ) {
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
return _ITRON_Task_Clarify_get_id_error( tskid );
case OBJECTS_LOCAL:
if ( location != OBJECTS_LOCAL )
return _ITRON_Task_Clarify_get_id_error( tskid );
/*
* The following are extended functions [level X ].
* XXX - tskwait, wid, wupcnt, and tskatr are presently not implemented.
*/
pk_rtsk->tskwait = 0;
pk_rtsk->wid = 0;
pk_rtsk->wupcnt = 0;
pk_rtsk->suscnt = the_thread->suspend_count;
pk_rtsk->tskatr = 0; /* XXX - Not correctly implemented */
pk_rtsk->task = (FP) the_thread->Start.entry_point;
core_priority = the_thread->Start.initial_priority;
pk_rtsk->itskpri = _ITRON_Task_Core_to_Priority( core_priority );
pk_rtsk->stksz = the_thread->Start.Initial_stack.size;
/*
* The following are required.
*/
pk_rtsk->exinf = NULL; /* extended information */
pk_rtsk->tskpri =
_ITRON_Task_Core_to_Priority(the_thread->current_priority);
/*
* Mask in the tskstat information
* Convert the task state XXX double check this
*/
pk_rtsk->tskstat = 0;
if ( the_thread == _Thread_Executing )
pk_rtsk->tskstat |= TTS_RUN;
if ( _States_Is_ready(the_thread->current_state) )
pk_rtsk->tskstat |= TTS_RDY;
if ( _States_Is_dormant( the_thread->current_state) )
pk_rtsk->tskstat |= TTS_DMT;
if ( _States_Is_suspended(the_thread->current_state) )
pk_rtsk->tskstat |= TTS_SUS;
if ( _States_Is_blocked(the_thread->current_state) )
pk_rtsk->tskstat |= TTS_WAI;
break;
}
_ITRON_return_errorno( E_OK );
}
