list.h File Reference

Go to the source code of this file.

Classes
struct	xLIST_ITEM
struct	xMINI_LIST_ITEM
struct	xLIST

Macros
#define	configLIST_VOLATILE
#define	listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
#define	listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
#define	listFIRST_LIST_INTEGRITY_CHECK_VALUE
#define	listSECOND_LIST_INTEGRITY_CHECK_VALUE
#define	listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem)
#define	listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem)
#define	listSET_LIST_INTEGRITY_CHECK_1_VALUE(pxList)
#define	listSET_LIST_INTEGRITY_CHECK_2_VALUE(pxList)
#define	listTEST_LIST_ITEM_INTEGRITY(pxItem)
#define	listTEST_LIST_INTEGRITY(pxList)
#define	listSET_LIST_ITEM_OWNER(pxListItem, pxOwner)   ( ( pxListItem )->pvOwner = ( void * ) ( pxOwner ) )
#define	listGET_LIST_ITEM_OWNER(pxListItem)   ( ( pxListItem )->pvOwner )
#define	listSET_LIST_ITEM_VALUE(pxListItem, xValue)   ( ( pxListItem )->xItemValue = ( xValue ) )
#define	listGET_LIST_ITEM_VALUE(pxListItem)   ( ( pxListItem )->xItemValue )
#define	listGET_ITEM_VALUE_OF_HEAD_ENTRY(pxList)   ( ( ( pxList )->xListEnd ).pxNext->xItemValue )
#define	listGET_HEAD_ENTRY(pxList)   ( ( ( pxList )->xListEnd ).pxNext )
#define	listGET_NEXT(pxListItem)   ( ( pxListItem )->pxNext )
#define	listGET_END_MARKER(pxList)   ( ( ListItem_t const * ) ( &( ( pxList )->xListEnd ) ) )
#define	listLIST_IS_EMPTY(pxList)   ( ( BaseType_t ) ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) )
#define	listCURRENT_LIST_LENGTH(pxList)   ( ( pxList )->uxNumberOfItems )
#define	listGET_OWNER_OF_NEXT_ENTRY(pxTCB, pxList)
#define	listGET_OWNER_OF_HEAD_ENTRY(pxList)   ( (&( ( pxList )->xListEnd ))->pxNext->pvOwner )
#define	listIS_CONTAINED_WITHIN(pxList, pxListItem)   ( ( BaseType_t ) ( ( pxListItem )->pvContainer == ( void * ) ( pxList ) ) )
#define	listLIST_ITEM_CONTAINER(pxListItem)   ( ( pxListItem )->pvContainer )
#define	listLIST_IS_INITIALISED(pxList)   ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )

Typedefs
typedef struct xLIST_ITEM	ListItem_t
typedef struct xMINI_LIST_ITEM	MiniListItem_t
typedef struct xLIST	List_t

Functions
PRIVILEGED_FUNCTION void	vListInitialise (List_t *const pxList)
PRIVILEGED_FUNCTION void	vListInitialiseItem (ListItem_t *const pxItem)
PRIVILEGED_FUNCTION void	vListInsert (List_t *const pxList, ListItem_t *const pxNewListItem)
PRIVILEGED_FUNCTION void	vListInsertEnd (List_t *const pxList, ListItem_t *const pxNewListItem)
PRIVILEGED_FUNCTION UBaseType_t	uxListRemove (ListItem_t *const pxItemToRemove)

Macro Definition Documentation

configLIST_VOLATILE

#define configLIST_VOLATILE

listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE

#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE

listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE

#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE

listFIRST_LIST_INTEGRITY_CHECK_VALUE

#define listFIRST_LIST_INTEGRITY_CHECK_VALUE

listSECOND_LIST_INTEGRITY_CHECK_VALUE

#define listSECOND_LIST_INTEGRITY_CHECK_VALUE

listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE

#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE

(

pxItem

)

listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE

#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE

(

pxItem

)

listSET_LIST_INTEGRITY_CHECK_1_VALUE

#define listSET_LIST_INTEGRITY_CHECK_1_VALUE

(

pxList

)

listSET_LIST_INTEGRITY_CHECK_2_VALUE

#define listSET_LIST_INTEGRITY_CHECK_2_VALUE

(

pxList

)

listTEST_LIST_ITEM_INTEGRITY

#define listTEST_LIST_ITEM_INTEGRITY

(

pxItem

)

listTEST_LIST_INTEGRITY

#define listTEST_LIST_INTEGRITY

(

pxList

)

listSET_LIST_ITEM_OWNER

#define listSET_LIST_ITEM_OWNER	(		pxListItem,
			pxOwner
	)		( ( pxListItem )->pvOwner = ( void * ) ( pxOwner ) )

listGET_LIST_ITEM_OWNER

#define listGET_LIST_ITEM_OWNER

(

pxListItem

)

( ( pxListItem )->pvOwner )

listSET_LIST_ITEM_VALUE

#define listSET_LIST_ITEM_VALUE	(		pxListItem,
			xValue
	)		( ( pxListItem )->xItemValue = ( xValue ) )

listGET_LIST_ITEM_VALUE

#define listGET_LIST_ITEM_VALUE

(

pxListItem

)

( ( pxListItem )->xItemValue )

listGET_ITEM_VALUE_OF_HEAD_ENTRY

#define listGET_ITEM_VALUE_OF_HEAD_ENTRY

(

pxList

)

( ( ( pxList )->xListEnd ).pxNext->xItemValue )

listGET_HEAD_ENTRY

#define listGET_HEAD_ENTRY

(

pxList

)

( ( ( pxList )->xListEnd ).pxNext )

listGET_NEXT

#define listGET_NEXT

(

pxListItem

)

( ( pxListItem )->pxNext )

listGET_END_MARKER

#define listGET_END_MARKER

(

pxList

)

( ( ListItem_t const * ) ( &( ( pxList )->xListEnd ) ) )

listLIST_IS_EMPTY

#define listLIST_IS_EMPTY

(

pxList

)

( ( BaseType_t ) ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) )

listCURRENT_LIST_LENGTH

#define listCURRENT_LIST_LENGTH

(

pxList

)

( ( pxList )->uxNumberOfItems )

listGET_OWNER_OF_NEXT_ENTRY

#define listGET_OWNER_OF_NEXT_ENTRY	(		pxTCB,
			pxList
	)

Value:

{                                                                                           \
List_t * const pxConstList = ( pxList );                                                    \
    /* Increment the index to the next item and return the item, ensuring */                \
    /* we don't return the marker used at the end of the list.  */                          \
    ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;                            \
    if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) )  \
    {                                                                                       \
        ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;                        \
    }                                                                                       \
    ( pxTCB ) = ( pxConstList )->pxIndex->pvOwner;                                          \
}

listGET_OWNER_OF_HEAD_ENTRY

#define listGET_OWNER_OF_HEAD_ENTRY

(

pxList

)

( (&( ( pxList )->xListEnd ))->pxNext->pvOwner )

listIS_CONTAINED_WITHIN

#define listIS_CONTAINED_WITHIN	(		pxList,
			pxListItem
	)		( ( BaseType_t ) ( ( pxListItem )->pvContainer == ( void * ) ( pxList ) ) )

listLIST_ITEM_CONTAINER

#define listLIST_ITEM_CONTAINER

(

pxListItem

)

( ( pxListItem )->pvContainer )

listLIST_IS_INITIALISED

#define listLIST_IS_INITIALISED

(

pxList

)

( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )

Typedef Documentation

ListItem_t

typedef struct xLIST_ITEM ListItem_t

MiniListItem_t

typedef struct xMINI_LIST_ITEM MiniListItem_t

List_t

typedef struct xLIST List_t

Function Documentation

vListInitialise()

PRIVILEGED_FUNCTION void vListInitialise

(

List_t *const

pxList

)

{
    /* The list structure contains a list item which is used to mark the
    end of the list.  To initialise the list the list end is inserted
    as the only list entry. */
    pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd );           /*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
 
    /* The list end value is the highest possible value in the list to
    ensure it remains at the end of the list. */
    pxList->xListEnd.xItemValue = portMAX_DELAY;
 
    /* The list end next and previous pointers point to itself so we know
    when the list is empty. */
    pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd );   /*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
    pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd );/*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
 
    pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
 
    /* Write known values into the list if
    configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
    listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
    listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
}

Here is the caller graph for this function:

vListInitialiseItem()

PRIVILEGED_FUNCTION void vListInitialiseItem

(

ListItem_t *const

pxItem

)

{
    /* Make sure the list item is not recorded as being on a list. */
    pxItem->pvContainer = NULL;
 
    /* Write known values into the list item if
    configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
    listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
    listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
}

Here is the caller graph for this function:

vListInsert()

PRIVILEGED_FUNCTION void vListInsert	(	List_t *const	pxList,
		ListItem_t *const	pxNewListItem
	)

{
ListItem_t *pxIterator;
const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
 
    /* Only effective when configASSERT() is also defined, these tests may catch
    the list data structures being overwritten in memory.  They will not catch
    data errors caused by incorrect configuration or use of FreeRTOS. */
    listTEST_LIST_INTEGRITY( pxList );
    listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
 
    /* Insert the new list item into the list, sorted in xItemValue order.
 
    If the list already contains a list item with the same item value then the
    new list item should be placed after it.  This ensures that TCB's which are
    stored in ready lists (all of which have the same xItemValue value) get a
    share of the CPU.  However, if the xItemValue is the same as the back marker
    the iteration loop below will not end.  Therefore the value is checked
    first, and the algorithm slightly modified if necessary. */
    if( xValueOfInsertion == portMAX_DELAY )
    {
        pxIterator = pxList->xListEnd.pxPrevious;
    }
    else
    {
        /* *** NOTE ***********************************************************
        If you find your application is crashing here then likely causes are
        listed below.  In addition see http://www.freertos.org/FAQHelp.html for
        more tips, and ensure configASSERT() is defined!
        http://www.freertos.org/a00110.html#configASSERT
 
            1) Stack overflow -
               see http://www.freertos.org/Stacks-and-stack-overflow-checking.html
            2) Incorrect interrupt priority assignment, especially on Cortex-M
               parts where numerically high priority values denote low actual
               interrupt priorities, which can seem counter intuitive.  See
               http://www.freertos.org/RTOS-Cortex-M3-M4.html and the definition
               of configMAX_SYSCALL_INTERRUPT_PRIORITY on
               http://www.freertos.org/a00110.html
            3) Calling an API function from within a critical section or when
               the scheduler is suspended, or calling an API function that does
               not end in "FromISR" from an interrupt.
            4) Using a queue or semaphore before it has been initialised or
               before the scheduler has been started (are interrupts firing
               before vTaskStartScheduler() has been called?).
        **********************************************************************/
 
        for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext ) /*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
        {
            /* There is nothing to do here, just iterating to the wanted
            insertion position. */
        }
    }
 
    pxNewListItem->pxNext = pxIterator->pxNext;
    pxNewListItem->pxNext->pxPrevious = pxNewListItem;
    pxNewListItem->pxPrevious = pxIterator;
    pxIterator->pxNext = pxNewListItem;
 
    /* Remember which list the item is in.  This allows fast removal of the
    item later. */
    pxNewListItem->pvContainer = ( void * ) pxList;
 
    ( pxList->uxNumberOfItems )++;
}

Here is the caller graph for this function:

vListInsertEnd()

PRIVILEGED_FUNCTION void vListInsertEnd	(	List_t *const	pxList,
		ListItem_t *const	pxNewListItem
	)

{
ListItem_t * const pxIndex = pxList->pxIndex;
 
    /* Only effective when configASSERT() is also defined, these tests may catch
    the list data structures being overwritten in memory.  They will not catch
    data errors caused by incorrect configuration or use of FreeRTOS. */
    listTEST_LIST_INTEGRITY( pxList );
    listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
 
    /* Insert a new list item into pxList, but rather than sort the list,
    makes the new list item the last item to be removed by a call to
    listGET_OWNER_OF_NEXT_ENTRY(). */
    pxNewListItem->pxNext = pxIndex;
    pxNewListItem->pxPrevious = pxIndex->pxPrevious;
 
    /* Only used during decision coverage testing. */
    mtCOVERAGE_TEST_DELAY();
 
    pxIndex->pxPrevious->pxNext = pxNewListItem;
    pxIndex->pxPrevious = pxNewListItem;
 
    /* Remember which list the item is in. */
    pxNewListItem->pvContainer = ( void * ) pxList;
 
    ( pxList->uxNumberOfItems )++;
}

Here is the caller graph for this function:

uxListRemove()

PRIVILEGED_FUNCTION UBaseType_t uxListRemove

(

ListItem_t *const

pxItemToRemove

)

{
/* The list item knows which list it is in.  Obtain the list from the list
item. */
List_t * const pxList = ( List_t * ) pxItemToRemove->pvContainer;
 
    pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
    pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;
 
    /* Only used during decision coverage testing. */
    mtCOVERAGE_TEST_DELAY();
 
    /* Make sure the index is left pointing to a valid item. */
    if( pxList->pxIndex == pxItemToRemove )
    {
        pxList->pxIndex = pxItemToRemove->pxPrevious;
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
 
    pxItemToRemove->pvContainer = NULL;
    ( pxList->uxNumberOfItems )--;
 
    return pxList->uxNumberOfItems;
}

Here is the caller graph for this function: