/*!
* \brief Marks the message as "free".
*
* Only the task that has the message as its resource can free the message. A
* message becomes a task's resource when the task allocates the message, and it
* continues to be a resource until the task either frees it or puts it in a
* message queue. A message becomes a resource of the task that got it from a
* message queue.
* \n The function returns the message to the message pool from which it was
* allocated.
*
* \param[in] msg_ptr Pointer to a message struct which is to be freed.
*
* \warning On failure, calls _task_set_error() to set one the following task
* error codes:
* \li MQX_INVALID_POINTER (Msg_ptr does not point to a valid message.)
* \li MQX_NOT_RESOURCE_OWNER (Message is already freed.)
* \li MSGQ_MESSAGE_IS_QUEUED (Message is in a queue.)
*
* \see _msgpool_create
* \see _msgpool_create_system
* \see _msgpool_destroy
* \see _msg_alloc_system
* \see _msg_alloc
* \see _task_set_error
* \see MESSAGE_HEADER_STRUCT
*/
void _msg_free
(
pointer msg_ptr
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
register INTERNAL_MESSAGE_STRUCT_PTR imsg_ptr;
register MSGPOOL_STRUCT_PTR msgpool_ptr;
_GET_KERNEL_DATA(kernel_data);
_KLOGE2(KLOG_msg_free, msg_ptr);
imsg_ptr = GET_INTERNAL_MESSAGE_PTR(msg_ptr);
#if MQX_CHECK_VALIDITY
if ( imsg_ptr->VALID != MSG_VALID )
{
_KLOGX2(KLOG_msg_free, MQX_INVALID_POINTER);
_task_set_error(MQX_INVALID_POINTER);
return;
} /* Endif */
#endif
#if MQX_CHECK_ERRORS
if (imsg_ptr->FREE)
{
_KLOGX2(KLOG_msg_free, MQX_NOT_RESOURCE_OWNER);
_task_set_error(MQX_NOT_RESOURCE_OWNER);
return;
} /* Endif */
if (imsg_ptr->QUEUED)
{
_KLOGX2(KLOG_msg_free, MSGQ_MESSAGE_IS_QUEUED);
_task_set_error(MSGQ_MESSAGE_IS_QUEUED);
return;
} /* Endif */
#endif
msgpool_ptr = imsg_ptr->MSGPOOL_PTR;
imsg_ptr->FREE = TRUE;
imsg_ptr->QUEUED = FALSE;
_INT_DISABLE();
/* Link onto the free list */
imsg_ptr->NEXT = msgpool_ptr->MSG_FREE_LIST_PTR;
msgpool_ptr->MSG_FREE_LIST_PTR = imsg_ptr;
++msgpool_ptr->SIZE;
_INT_ENABLE();
_KLOGX2(KLOG_msg_free, MQX_OK);
} /* Endbody */
MESSAGE_HEADER_STRUCT_PTR _msgq_receive_internal
(
/* [IN] id of the queue from which a message is to be received */
_queue_id queue_id,
/* [IN] indication of the number of ticks which can expire before
** this request times out
*/
MQX_TICK_STRUCT_PTR timeout_tick_ptr,
/* [IN] relative or absolute time specified in tick_ptr */
_mqx_uint mode,
/* [OUT] where the error code is to be stored */
_mqx_uint_ptr error_ptr
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
MSG_COMPONENT_STRUCT_PTR msg_component_ptr;
register TD_STRUCT_PTR td_ptr;
MESSAGE_HEADER_STRUCT_PTR message_ptr;
register INTERNAL_MESSAGE_STRUCT_PTR imsg_ptr;
register MSGQ_STRUCT_PTR msgq_ptr;
_queue_number queue;
*error_ptr = MQX_OK;
_GET_KERNEL_DATA(kernel_data);
#if MQX_CHECK_ERRORS
if (kernel_data->IN_ISR) {
_task_set_error(MQX_CANNOT_CALL_FUNCTION_FROM_ISR);
*error_ptr = MQX_CANNOT_CALL_FUNCTION_FROM_ISR;
return(NULL);
}/* Endif */
#endif
msg_component_ptr = _GET_MSG_COMPONENT_STRUCT_PTR(kernel_data);
#if MQX_CHECK_ERRORS
if (msg_component_ptr == NULL){
_task_set_error(MQX_COMPONENT_DOES_NOT_EXIST);
*error_ptr = MQX_COMPONENT_DOES_NOT_EXIST;
return(NULL);
} /* Endif */
#endif
message_ptr = NULL;
td_ptr = kernel_data->ACTIVE_PTR;
if (queue_id == MSGQ_ANY_QUEUE){
/* if queue_id is 0 than a receive from any queue is performed */
/* Does the task own a queue */
if (td_ptr->MSG_QUEUE_HEAD == NULL){
/* Does NOT */
_task_set_error(MSGQ_QUEUE_IS_NOT_OPEN);
*error_ptr = MSGQ_QUEUE_IS_NOT_OPEN;
return NULL;
} /* Endif */
_INT_DISABLE();
if (td_ptr->MESSAGES_AVAILABLE == 0){
td_ptr->STATE = RCV_ANY_BLOCKED;
td_ptr->INFO = queue_id;
td_ptr->MESSAGE = NULL;
if (mode == MSG_TIMEOUT_NONE) {
_task_block();
} else if (mode == MSG_TIMEOUT_RELATIVE) {
_time_delay_for(timeout_tick_ptr);
} else {
_time_delay_until(timeout_tick_ptr);
} /* Endif */
/*
** SHORT CUT...
** The message send routine does not queue up a message in this case.
** the message is deposited directly into the task descriptor
*/
message_ptr = (MESSAGE_HEADER_STRUCT_PTR)td_ptr->MESSAGE;
if (message_ptr == NULL){
/* A timeout has occurred */
#if MQXCFG_ENABLE_MSG_TIMEOUT_ERROR
_task_set_error(MSGQ_MESSAGE_NOT_AVAILABLE);
#endif
} /* Endif */
td_ptr->MESSAGE = NULL;
} else {
/* Check all queues for an available entry .. There must be at least
** one entry available
*/
msgq_ptr = (MSGQ_STRUCT_PTR)td_ptr->MSG_QUEUE_HEAD;
while (msgq_ptr != NULL){
if (msgq_ptr->NO_OF_ENTRIES){
/* dequeue the top entry */
DEQUEUE_TOP_MSG_ENTRY(msgq_ptr, imsg_ptr, message_ptr, td_ptr);
break;
} /* Endif */
msgq_ptr = msgq_ptr->NEXT_MSGQ_PTR;
} /* Endwhile */
} /* Endif */
} else {
/* RECEIVE from a specific qid */
queue = QUEUE_FROM_QID(queue_id);
#if MQX_CHECK_ERRORS
if ( (PROC_NUMBER_FROM_QID(queue_id) != kernel_data->INIT.PROCESSOR_NUMBER) ||
(! VALID_QUEUE(queue)) )
{
_task_set_error(MSGQ_INVALID_QUEUE_ID);
*error_ptr = MSGQ_INVALID_QUEUE_ID;
return (pointer)message_ptr;
} /* Endif */
#endif
msgq_ptr = &msg_component_ptr->MSGQS_PTR[queue];
#if MQX_CHECK_ERRORS
if ( msgq_ptr->QUEUE != queue ) {
_task_set_error(MSGQ_QUEUE_IS_NOT_OPEN);
*error_ptr = MSGQ_QUEUE_IS_NOT_OPEN;
return message_ptr;
} /* Endif */
if ( (msgq_ptr->TD_PTR != NULL) && (msgq_ptr->TD_PTR != td_ptr) ) {
_task_set_error(MSGQ_NOT_QUEUE_OWNER);
*error_ptr = MSGQ_NOT_QUEUE_OWNER;
return message_ptr;
} /* Endif */
#endif
/*
** check the specified queue for an entry
** if not entry, then block until an entry is received or
** timeout occurs
*/
_INT_DISABLE();
if (msgq_ptr->NO_OF_ENTRIES == 0) {
if (msgq_ptr->TD_PTR == NULL) {
/* A system message queue, indicate none available */
message_ptr = NULL;
} else {
td_ptr->STATE = RCV_SPECIFIC_BLOCKED;
td_ptr->INFO = queue;
td_ptr->MESSAGE = NULL;
if (mode == MSG_TIMEOUT_NONE) {
_task_block();
} else if (mode == MSG_TIMEOUT_RELATIVE) {
_time_delay_for(timeout_tick_ptr);
} else {
_time_delay_until(timeout_tick_ptr);
} /* Endif */
message_ptr = (MESSAGE_HEADER_STRUCT_PTR)td_ptr->MESSAGE;
if ( message_ptr == NULL ) {
#if MQXCFG_ENABLE_MSG_TIMEOUT_ERROR
_task_set_error(MSGQ_MESSAGE_NOT_AVAILABLE);
#endif
} else if ((message_ptr->TARGET_QID != queue_id) &&
(msgq_ptr->NO_OF_ENTRIES > 0)) {
/* The original msg was swapped out in msgq_sendi() for
a higher priority msg with a different target_qid.
Enqueue this msg, and then dequeue the msg we need.
*/
register MSGQ_STRUCT_PTR tmp_msgq_ptr;
register _queue_number tmp_queue;
/* Get the msg's queue */
tmp_queue = QUEUE_FROM_QID(message_ptr->TARGET_QID);
tmp_msgq_ptr = &msg_component_ptr->MSGQS_PTR[tmp_queue];
if ((tmp_msgq_ptr->MAX_ENTRIES == 0) ||
(tmp_msgq_ptr->NO_OF_ENTRIES < tmp_msgq_ptr->MAX_ENTRIES))
{
/* the msg's queue has room */
imsg_ptr = GET_INTERNAL_MESSAGE_PTR(message_ptr);
#if MQX_CHECK_ERRORS
if (imsg_ptr->VALID != MSG_VALID){
/* An invalid message was input by the application. */
_task_set_error(MSGQ_INVALID_MESSAGE);
message_ptr = NULL;
} else
#endif
{
/* enqueue the msg */
_msgq_insert_message_internal(tmp_msgq_ptr, imsg_ptr, TRUE);
if (tmp_msgq_ptr->TD_PTR) {
++(tmp_msgq_ptr->TD_PTR->MESSAGES_AVAILABLE);
} /* Endif */
/* now dequeue our queue's top entry */
DEQUEUE_TOP_MSG_ENTRY(msgq_ptr, imsg_ptr, message_ptr, td_ptr);
}
} else {
/* Queue full, error - this should not happen
since msgq_sendi() checks for room on the queue
for all msgs, including short-cut msgs. */
_task_set_error(MSGQ_QUEUE_FULL);
message_ptr = NULL;
}
} /* Endif */
td_ptr->MESSAGE = NULL;
} /* Endif */
} else {
/* dequeue the top entry */
DEQUEUE_TOP_MSG_ENTRY(msgq_ptr, imsg_ptr, message_ptr, td_ptr);
} /* Endif */
} /* Endif */
_INT_ENABLE();
return message_ptr;
} /* Endbody */
boolean _msgq_send_internal
(
/* [IN] pointer to the message being sent by application */
MESSAGE_HEADER_STRUCT_PTR msg_ptr,
/* [IN] is the calling task to be blocked after the call */
boolean blocking,
/* [IN] the queue to put the message onto */
_queue_id target_qid
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
MSG_COMPONENT_STRUCT_PTR msg_component_ptr;
register INTERNAL_MESSAGE_STRUCT_PTR imsg_ptr;
register MSGQ_STRUCT_PTR msgq_ptr;
register TD_STRUCT_PTR td_ptr;
MESSAGE_HEADER_STRUCT_PTR tmp_msg_ptr;
register _mqx_uint state;
register _queue_number queue;
register _processor_number pnum;
/* Start CR 2191 */
boolean swapped_msg;
/* End CR 2191 */
_GET_KERNEL_DATA(kernel_data);
msg_component_ptr = _GET_MSG_COMPONENT_STRUCT_PTR(kernel_data);
#if MQX_CHECK_ERRORS
if (msg_component_ptr == NULL){
_task_set_error(MQX_COMPONENT_DOES_NOT_EXIST);
return(FALSE);
} /* Endif */
if (msg_ptr == NULL) {
_task_set_error(MSGQ_INVALID_MESSAGE);
return(FALSE);
} /* Endif */
#endif
imsg_ptr = GET_INTERNAL_MESSAGE_PTR(msg_ptr);
#if MQX_CHECK_ERRORS
if (imsg_ptr->VALID != MSG_VALID){
/* An invalid message was input by the application. */
_task_set_error(MSGQ_INVALID_MESSAGE);
return FALSE;
} /* Endif */
#endif
#if MQX_CHECK_ERRORS
if (imsg_ptr->FREE || imsg_ptr->QUEUED){
/* Trying to send a free message, or one on a message queue. */
_task_set_error(MSGQ_INVALID_MESSAGE);
return FALSE;
} /* Endif */
#endif
pnum = PROC_NUMBER_FROM_QID(target_qid);
/* If processor number is zero then the message is for this processor */
if (pnum == 0) {
/* Fix up the target QID in the message header */
msg_ptr->TARGET_QID = BUILD_QID(kernel_data->INIT.PROCESSOR_NUMBER,
msg_ptr->TARGET_QID);
} else if (pnum != kernel_data->INIT.PROCESSOR_NUMBER) {
#if MQX_IS_MULTI_PROCESSOR
IPC_MSG_ROUTING_COMPONENT_STRUCT_PTR ipc_msg_comp_ptr;
ipc_msg_comp_ptr = (IPC_MSG_ROUTING_COMPONENT_STRUCT_PTR)
kernel_data->KERNEL_COMPONENTS[KERNEL_IPC_MSG_ROUTING];
if (ipc_msg_comp_ptr && ipc_msg_comp_ptr->MSG_ROUTER) {
return( (*ipc_msg_comp_ptr->MSG_ROUTER)(pnum, msg_ptr, blocking));
} else {
#endif
_msg_free(msg_ptr);
_task_set_error(MSGQ_INVALID_QUEUE_ID);
return FALSE;
#if MQX_IS_MULTI_PROCESSOR
}/* Endif */
#endif
} /* Endif */
queue = QUEUE_FROM_QID(target_qid);
#if MQX_CHECK_ERRORS
if ( ! VALID_QUEUE(queue)) {
_msg_free(msg_ptr);
_task_set_error(MSGQ_INVALID_QUEUE_ID);
return FALSE;
} /* Endif */
#endif
msgq_ptr = &msg_component_ptr->MSGQS_PTR[queue];
if (msgq_ptr->QUEUE != queue) {
msgq_ptr = NULL;
} /* Endif */
#if MQX_CHECK_ERRORS
if (msgq_ptr == NULL) {
_msg_free(msg_ptr);
_task_set_error(MSGQ_QUEUE_IS_NOT_OPEN);
return FALSE;
} /* Endif */
#endif
_INT_DISABLE();
if ((msgq_ptr->MAX_ENTRIES == 0) ||
(msgq_ptr->NO_OF_ENTRIES < msgq_ptr->MAX_ENTRIES))
{
/* End CR 2265 */
/* There is room on the queue, so add the msg. We
need to check for room here even if the msg ends up
being short-cutted to the receiver (via td_ptr->MESSAGE)
in case msg_receive needs to enqueue the msg.
*/
if (msgq_ptr->TYPE == MSG_QUEUE) {
/* THIS MESSAGE QUEUE IS ATTACHED TO A TASK */
/* check for pending receive
** if a receive is pending then satisfy the request
** and add the receiving task onto the ready-to-run queue
*/
td_ptr = msgq_ptr->TD_PTR;
state = td_ptr->STATE & STATE_MASK;
if ( (state == RCV_ANY_BLOCKED) ||
((state == RCV_SPECIFIC_BLOCKED) && (td_ptr->INFO == queue)))
{
/* The task is blocked, waiting for a message */
td_ptr->MESSAGE = &imsg_ptr->MESSAGE;
imsg_ptr->TD_PTR = td_ptr;
_TIME_DEQUEUE(td_ptr,kernel_data);
_TASK_READY(td_ptr,kernel_data);
/* Now run the notification function */
if (msgq_ptr->NOTIFICATION_FUNCTION != NULL) {
(*msgq_ptr->NOTIFICATION_FUNCTION)(msgq_ptr->NOTIFICATION_FUNCTION_PARAMETER);
} /* Endif */
if (blocking) {
if ( ! kernel_data->IN_ISR) {
td_ptr = kernel_data->ACTIVE_PTR;
td_ptr->STATE = SEND_BLOCKED;
_task_block();
} /* Endif */
} else {
/*
** if the highest priority ready task is not the
** same priority as the sending task, then a higher
** priority task was made ready and it has to be allowed
** to run.
*/
_CHECK_RUN_SCHEDULER(); /* Let a higher priority task run */
} /* Endif */
} else {
/* The task is ready to run and pre-empted OR blocked and
** on a different queue.
*/
/* Start CR 2191 */
swapped_msg = FALSE;
/* End CR 2191 */
if ((msg_ptr->CONTROL & MSG_PRIORITY_MASK) &&
(td_ptr->MESSAGE != NULL))
{
/* Check the message in the TD */
tmp_msg_ptr = (MESSAGE_HEADER_STRUCT_PTR)td_ptr->MESSAGE;
if ( (msg_ptr->CONTROL & MSG_HDR_URGENT) ||
/* Urgent messages first */
( (! (tmp_msg_ptr->CONTROL & MSG_HDR_URGENT)) &&
/* Start CR 621 */
( (_mqx_uint)(tmp_msg_ptr->CONTROL & MSG_HDR_PRIORITY_MASK) <
(_mqx_uint)(msg_ptr->CONTROL & MSG_HDR_PRIORITY_MASK))
/* End CR 621 */
)
)
/* Higher priority messages first */
{
/* Put new message into TD */
td_ptr->MESSAGE = msg_ptr;
/* Start CR 2193 */
/* Set the new message's ownership to the receiving queue's TD */
imsg_ptr = GET_INTERNAL_MESSAGE_PTR(msg_ptr);
imsg_ptr->TD_PTR = td_ptr;
/* Old message which we pulled from TD, need to add to queue, below */
/* End CR 2193 */
msg_ptr = tmp_msg_ptr;
imsg_ptr = GET_INTERNAL_MESSAGE_PTR(msg_ptr);
/* Don't know the sender's TD for the swapped out msg,
so set it to NULL; */
imsg_ptr->TD_PTR = NULL;
/* Start CR 2191 */
/* Indicate that a swap occurred */
swapped_msg = TRUE;
/* Set the queue to the swapped msg's queue. */
if (target_qid != msg_ptr->TARGET_QID)
{
queue = QUEUE_FROM_QID(msg_ptr->TARGET_QID);
msgq_ptr = &msg_component_ptr->MSGQS_PTR[queue];
/* This msg's queue was not full when it was short-cut,
so we should not get here. Check anyway. */
if ((msgq_ptr->MAX_ENTRIES != 0) &&
(msgq_ptr->NO_OF_ENTRIES >= msgq_ptr->MAX_ENTRIES))
{
/* Queue full, error */
_INT_ENABLE();
_msg_free(msg_ptr);
_task_set_error(MSGQ_QUEUE_FULL);
return FALSE;
} /* Endif */
} /* Endif */
} /* Endif */
} /* Endif */
/* add the message */
_msgq_insert_message_internal(msgq_ptr, imsg_ptr, swapped_msg);
if (msgq_ptr->TD_PTR){
++(msgq_ptr->TD_PTR->MESSAGES_AVAILABLE);
} /* Endif */
/* Now run the notification function */
if (msgq_ptr->NOTIFICATION_FUNCTION != NULL) {
(*msgq_ptr->NOTIFICATION_FUNCTION)(msgq_ptr->NOTIFICATION_FUNCTION_PARAMETER);
} /* Endif */
if (blocking && ! kernel_data->IN_ISR ) {
td_ptr = kernel_data->ACTIVE_PTR;
td_ptr->STATE = SEND_BLOCKED;
_task_block();
} /* Endif */
} /* Endif */
} else {
/* THIS IS A SYSTEM QUEUE NOT ATTACHED TO A TASK */
/* add the message to the queue */
_msgq_insert_message_internal(msgq_ptr, imsg_ptr, FALSE);
/* Run the notification function. */
if ( msgq_ptr->NOTIFICATION_FUNCTION != NULL ) {
(*msgq_ptr->NOTIFICATION_FUNCTION)(msgq_ptr->NOTIFICATION_FUNCTION_PARAMETER);
} /* Endif */
} /* Endif */
} else {
/* Queue full, error */
_INT_ENABLE();
_task_set_error(MSGQ_QUEUE_FULL);
_msg_free(&imsg_ptr->MESSAGE);
return FALSE;
} /* Endif */
_INT_ENABLE();
return TRUE; /* Message sent MQX_OK */
} /* Endbody */
