len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2026-05-12 11:42:57 -04:00
Code Issues Projects Releases Packages Wiki Activity

Remove post-timeout re-check in queue receive paths

Browse source 
xQueueReceive, xQueueSemaphoreTake, and xQueuePeek re-checked the
queue state after timeout expiry and looped back if data had arrived,
while xQueueGenericSend returned errQUEUE_FULL directly on timeout.

Remove the post-timeout re-check from all three receive-side functions
to make timeout behavior symmetric with the send path. Once the
timeout has expired, return errQUEUE_EMPTY directly.

For xQueueSemaphoreTake, the mutex priority disinheritance logic is
retained and now runs unconditionally on timeout.

Refs https://github.com/FreeRTOS/FreeRTOS/issues/65
Forum: https://forums.freertos.org/t/xqueuegenericsend-and-xqueuereceive/24856
This commit is contained in:
AniruddhaKanhere 2026-04-22 17:19:46 -07:00
parent 587fe6df0d
commit 5b9a8ca934
1 changed files with 36 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

99
queue.c
View file

@ -1635,22 +1635,14 @@ BaseType_t xQueueReceive( QueueHandle_t xQueue,
}
else
{
/* Timed out. If there is no data in the queue exit, otherwise loop
* back and attempt to read the data. */
/* The timeout has expired. */
prvUnlockQueue( pxQueue );
( void ) xTaskResumeAll();
if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
{
traceQUEUE_RECEIVE_FAILED( pxQueue );
traceRETURN_xQueueReceive( errQUEUE_EMPTY );
traceQUEUE_RECEIVE_FAILED( pxQueue );
traceRETURN_xQueueReceive( errQUEUE_EMPTY );
return errQUEUE_EMPTY;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
return errQUEUE_EMPTY;
}
}
}
@ -1829,53 +1821,42 @@ BaseType_t xQueueSemaphoreTake( QueueHandle_t xQueue,
prvUnlockQueue( pxQueue );
( void ) xTaskResumeAll();
/* If the semaphore count is 0 exit now as the timeout has
* expired. Otherwise return to attempt to take the semaphore that is
* known to be available. As semaphores are implemented by queues the
* queue being empty is equivalent to the semaphore count being 0. */
if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
#if ( configUSE_MUTEXES == 1 )
{
#if ( configUSE_MUTEXES == 1 )
/* xInheritanceOccurred could only have be set if
* pxQueue->uxQueueType == queueQUEUE_IS_MUTEX so no need to
* test the mutex type again to check it is actually a mutex. */
if( xInheritanceOccurred != pdFALSE )
{
/* xInheritanceOccurred could only have be set if
* pxQueue->uxQueueType == queueQUEUE_IS_MUTEX so no need to
* test the mutex type again to check it is actually a mutex. */
if( xInheritanceOccurred != pdFALSE )
taskENTER_CRITICAL();
{
taskENTER_CRITICAL();
{
UBaseType_t uxHighestWaitingPriority;
UBaseType_t uxHighestWaitingPriority;
/* This task blocking on the mutex caused another
* task to inherit this task's priority. Now this task
* has timed out the priority should be disinherited
* again, but only as low as the next highest priority
* task that is waiting for the same mutex. */
uxHighestWaitingPriority = prvGetHighestPriorityOfWaitToReceiveList( pxQueue );
/* This task blocking on the mutex caused another
* task to inherit this task's priority. Now this task
* has timed out the priority should be disinherited
* again, but only as low as the next highest priority
* task that is waiting for the same mutex. */
uxHighestWaitingPriority = prvGetHighestPriorityOfWaitToReceiveList( pxQueue );
/* vTaskPriorityDisinheritAfterTimeout uses the uxHighestWaitingPriority
* parameter to index pxReadyTasksLists when adding the task holding
* mutex to the ready list for its new priority. Coverity thinks that
* it can result in out-of-bounds access which is not true because
* uxHighestWaitingPriority, as returned by prvGetHighestPriorityOfWaitToReceiveList,
* is capped at ( configMAX_PRIORITIES - 1 ). */
/* coverity[overrun] */
vTaskPriorityDisinheritAfterTimeout( pxQueue->u.xSemaphore.xMutexHolder, uxHighestWaitingPriority );
}
taskEXIT_CRITICAL();
/* vTaskPriorityDisinheritAfterTimeout uses the uxHighestWaitingPriority
* parameter to index pxReadyTasksLists when adding the task holding
* mutex to the ready list for its new priority. Coverity thinks that
* it can result in out-of-bounds access which is not true because
* uxHighestWaitingPriority, as returned by prvGetHighestPriorityOfWaitToReceiveList,
* is capped at ( configMAX_PRIORITIES - 1 ). */
/* coverity[overrun] */
vTaskPriorityDisinheritAfterTimeout( pxQueue->u.xSemaphore.xMutexHolder, uxHighestWaitingPriority );
}
taskEXIT_CRITICAL();
}
#endif /* configUSE_MUTEXES */
traceQUEUE_RECEIVE_FAILED( pxQueue );
traceRETURN_xQueueSemaphoreTake( errQUEUE_EMPTY );
return errQUEUE_EMPTY;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
#endif /* configUSE_MUTEXES */
traceQUEUE_RECEIVE_FAILED( pxQueue );
traceRETURN_xQueueSemaphoreTake( errQUEUE_EMPTY );
return errQUEUE_EMPTY;
}
}
}
@ -2015,22 +1996,14 @@ BaseType_t xQueuePeek( QueueHandle_t xQueue,
}
else
{
/* The timeout has expired. If there is still no data in the queue
* exit, otherwise go back and try to read the data again. */
/* The timeout has expired. */
prvUnlockQueue( pxQueue );
( void ) xTaskResumeAll();
if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
{
traceQUEUE_PEEK_FAILED( pxQueue );
traceRETURN_xQueuePeek( errQUEUE_EMPTY );
traceQUEUE_PEEK_FAILED( pxQueue );
traceRETURN_xQueuePeek( errQUEUE_EMPTY );
return errQUEUE_EMPTY;
}
else
{
mtCOVERAGE_TEST_MARKER();
}
return errQUEUE_EMPTY;
}
}
}