mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
508 lines
23 KiB
C
508 lines
23 KiB
C
/*
|
|
* FreeRTOS Kernel V10.5.1 (ESP-IDF SMP modified)
|
|
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
*
|
|
* SPDX-FileCopyrightText: 2021 Amazon.com, Inc. or its affiliates
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
* SPDX-FileContributor: 2023 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
* the Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* https://www.FreeRTOS.org
|
|
* https://github.com/FreeRTOS
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* This is the list implementation used by the scheduler. While it is tailored
|
|
* heavily for the schedulers needs, it is also available for use by
|
|
* application code.
|
|
*
|
|
* list_ts can only store pointers to list_item_ts. Each ListItem_t contains a
|
|
* numeric value (xItemValue). Most of the time the lists are sorted in
|
|
* ascending item value order.
|
|
*
|
|
* Lists are created already containing one list item. The value of this
|
|
* item is the maximum possible that can be stored, it is therefore always at
|
|
* the end of the list and acts as a marker. The list member pxHead always
|
|
* points to this marker - even though it is at the tail of the list. This
|
|
* is because the tail contains a wrap back pointer to the true head of
|
|
* the list.
|
|
*
|
|
* In addition to it's value, each list item contains a pointer to the next
|
|
* item in the list (pxNext), a pointer to the list it is in (pxContainer)
|
|
* and a pointer to back to the object that contains it. These later two
|
|
* pointers are included for efficiency of list manipulation. There is
|
|
* effectively a two way link between the object containing the list item and
|
|
* the list item itself.
|
|
*
|
|
*
|
|
* \page ListIntroduction List Implementation
|
|
* \ingroup FreeRTOSIntro
|
|
*/
|
|
|
|
|
|
#ifndef LIST_H
|
|
#define LIST_H
|
|
|
|
#ifndef INC_FREERTOS_H
|
|
#error "FreeRTOS.h must be included before list.h"
|
|
#endif
|
|
|
|
/*
|
|
* The list structure members are modified from within interrupts, and therefore
|
|
* by rights should be declared volatile. However, they are only modified in a
|
|
* functionally atomic way (within critical sections of with the scheduler
|
|
* suspended) and are either passed by reference into a function or indexed via
|
|
* a volatile variable. Therefore, in all use cases tested so far, the volatile
|
|
* qualifier can be omitted in order to provide a moderate performance
|
|
* improvement without adversely affecting functional behaviour. The assembly
|
|
* instructions generated by the IAR, ARM and GCC compilers when the respective
|
|
* compiler's options were set for maximum optimisation has been inspected and
|
|
* deemed to be as intended. That said, as compiler technology advances, and
|
|
* especially if aggressive cross module optimisation is used (a use case that
|
|
* has not been exercised to any great extend) then it is feasible that the
|
|
* volatile qualifier will be needed for correct optimisation. It is expected
|
|
* that a compiler removing essential code because, without the volatile
|
|
* qualifier on the list structure members and with aggressive cross module
|
|
* optimisation, the compiler deemed the code unnecessary will result in
|
|
* complete and obvious failure of the scheduler. If this is ever experienced
|
|
* then the volatile qualifier can be inserted in the relevant places within the
|
|
* list structures by simply defining configLIST_VOLATILE to volatile in
|
|
* FreeRTOSConfig.h (as per the example at the bottom of this comment block).
|
|
* If configLIST_VOLATILE is not defined then the preprocessor directives below
|
|
* will simply #define configLIST_VOLATILE away completely.
|
|
*
|
|
* To use volatile list structure members then add the following line to
|
|
* FreeRTOSConfig.h (without the quotes):
|
|
* "#define configLIST_VOLATILE volatile"
|
|
*/
|
|
#ifndef configLIST_VOLATILE
|
|
#define configLIST_VOLATILE
|
|
#endif /* configSUPPORT_CROSS_MODULE_OPTIMISATION */
|
|
|
|
/* *INDENT-OFF* */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
/* *INDENT-ON* */
|
|
|
|
/* Macros that can be used to place known values within the list structures,
|
|
* then check that the known values do not get corrupted during the execution of
|
|
* the application. These may catch the list data structures being overwritten in
|
|
* memory. They will not catch data errors caused by incorrect configuration or
|
|
* use of FreeRTOS.*/
|
|
#if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 )
|
|
/* Define the macros to do nothing. */
|
|
#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 )
|
|
#else /* if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 ) */
|
|
/* Define macros that add new members into the list structures. */
|
|
#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue1;
|
|
#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue2;
|
|
#define listFIRST_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue1;
|
|
#define listSECOND_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue2;
|
|
|
|
/* Define macros that set the new structure members to known values. */
|
|
#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
|
|
#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
|
|
#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList ) ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
|
|
#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList ) ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
|
|
|
|
/* Define macros that will assert if one of the structure members does not
|
|
* contain its expected value. */
|
|
#define listTEST_LIST_ITEM_INTEGRITY( pxItem ) configASSERT( ( ( pxItem )->xListItemIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxItem )->xListItemIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
|
|
#define listTEST_LIST_INTEGRITY( pxList ) configASSERT( ( ( pxList )->xListIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxList )->xListIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
|
|
#endif /* configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES */
|
|
|
|
|
|
/*
|
|
* Definition of the only type of object that a list can contain.
|
|
*/
|
|
struct xLIST;
|
|
struct xLIST_ITEM
|
|
{
|
|
listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
|
configLIST_VOLATILE TickType_t xItemValue; /*< The value being listed. In most cases this is used to sort the list in ascending order. */
|
|
struct xLIST_ITEM * configLIST_VOLATILE pxNext; /*< Pointer to the next ListItem_t in the list. */
|
|
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; /*< Pointer to the previous ListItem_t in the list. */
|
|
void * pvOwner; /*< Pointer to the object (normally a TCB) that contains the list item. There is therefore a two way link between the object containing the list item and the list item itself. */
|
|
struct xLIST * configLIST_VOLATILE pxContainer; /*< Pointer to the list in which this list item is placed (if any). */
|
|
listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
|
};
|
|
typedef struct xLIST_ITEM ListItem_t; /* For some reason lint wants this as two separate definitions. */
|
|
|
|
#if ( configUSE_MINI_LIST_ITEM == 1 )
|
|
struct xMINI_LIST_ITEM
|
|
{
|
|
listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
|
configLIST_VOLATILE TickType_t xItemValue;
|
|
struct xLIST_ITEM * configLIST_VOLATILE pxNext;
|
|
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
|
|
};
|
|
typedef struct xMINI_LIST_ITEM MiniListItem_t;
|
|
#else
|
|
typedef struct xLIST_ITEM MiniListItem_t;
|
|
#endif
|
|
|
|
/*
|
|
* Definition of the type of queue used by the scheduler.
|
|
*/
|
|
typedef struct xLIST
|
|
{
|
|
listFIRST_LIST_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
|
volatile UBaseType_t uxNumberOfItems;
|
|
ListItem_t * configLIST_VOLATILE pxIndex; /*< Used to walk through the list. Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */
|
|
MiniListItem_t xListEnd; /*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
|
|
listSECOND_LIST_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
|
} List_t;
|
|
|
|
/*
|
|
* Access macro to set the owner of a list item. The owner of a list item
|
|
* is the object (usually a TCB) that contains the list item.
|
|
*
|
|
* \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listSET_LIST_ITEM_OWNER( pxListItem, pxOwner ) ( ( pxListItem )->pvOwner = ( void * ) ( pxOwner ) )
|
|
|
|
/*
|
|
* Access macro to get the owner of a list item. The owner of a list item
|
|
* is the object (usually a TCB) that contains the list item.
|
|
*
|
|
* \page listGET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_LIST_ITEM_OWNER( pxListItem ) ( ( pxListItem )->pvOwner )
|
|
|
|
/*
|
|
* Access macro to set the value of the list item. In most cases the value is
|
|
* used to sort the list in ascending order.
|
|
*
|
|
* \page listSET_LIST_ITEM_VALUE listSET_LIST_ITEM_VALUE
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listSET_LIST_ITEM_VALUE( pxListItem, xValue ) ( ( pxListItem )->xItemValue = ( xValue ) )
|
|
|
|
/*
|
|
* Access macro to retrieve the value of the list item. The value can
|
|
* represent anything - for example the priority of a task, or the time at
|
|
* which a task should be unblocked.
|
|
*
|
|
* \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_LIST_ITEM_VALUE( pxListItem ) ( ( pxListItem )->xItemValue )
|
|
|
|
/*
|
|
* Access macro to retrieve the value of the list item at the head of a given
|
|
* list.
|
|
*
|
|
* \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxList ) ( ( ( pxList )->xListEnd ).pxNext->xItemValue )
|
|
|
|
/*
|
|
* Return the list item at the head of the list.
|
|
*
|
|
* \page listGET_HEAD_ENTRY listGET_HEAD_ENTRY
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_HEAD_ENTRY( pxList ) ( ( ( pxList )->xListEnd ).pxNext )
|
|
|
|
/*
|
|
* Return the next list item.
|
|
*
|
|
* \page listGET_NEXT listGET_NEXT
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_NEXT( pxListItem ) ( ( pxListItem )->pxNext )
|
|
|
|
/*
|
|
* Return the list item that marks the end of the list
|
|
*
|
|
* \page listGET_END_MARKER listGET_END_MARKER
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_END_MARKER( pxList ) ( ( ListItem_t const * ) ( &( ( pxList )->xListEnd ) ) )
|
|
|
|
/*
|
|
* Access macro to determine if a list contains any items. The macro will
|
|
* only have the value true if the list is empty.
|
|
*
|
|
* \page listLIST_IS_EMPTY listLIST_IS_EMPTY
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listLIST_IS_EMPTY( pxList ) ( ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) ? pdTRUE : pdFALSE )
|
|
|
|
/*
|
|
* Access macro to return the number of items in the list.
|
|
*/
|
|
#define listCURRENT_LIST_LENGTH( pxList ) ( ( pxList )->uxNumberOfItems )
|
|
|
|
/*
|
|
* Access function to obtain the owner of the next entry in a list.
|
|
*
|
|
* The list member pxIndex is used to walk through a list. Calling
|
|
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list
|
|
* and returns that entry's pxOwner parameter. Using multiple calls to this
|
|
* function it is therefore possible to move through every item contained in
|
|
* a list.
|
|
*
|
|
* The pxOwner parameter of a list item is a pointer to the object that owns
|
|
* the list item. In the scheduler this is normally a task control block.
|
|
* The pxOwner parameter effectively creates a two way link between the list
|
|
* item and its owner.
|
|
*
|
|
* @param pxTCB pxTCB is set to the address of the owner of the next list item.
|
|
* @param pxList The list from which the next item owner is to be returned.
|
|
*
|
|
* \page listGET_OWNER_OF_NEXT_ENTRY listGET_OWNER_OF_NEXT_ENTRY
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList ) \
|
|
{ \
|
|
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; \
|
|
}
|
|
|
|
/*
|
|
* Version of uxListRemove() that does not return a value. Provided as a slight
|
|
* optimisation for xTaskIncrementTick() by being inline.
|
|
*
|
|
* Remove an item from a list. The list item has a pointer to the list that
|
|
* it is in, so only the list item need be passed into the function.
|
|
*
|
|
* @param uxListRemove The item to be removed. The item will remove itself from
|
|
* the list pointed to by it's pxContainer parameter.
|
|
*
|
|
* @return The number of items that remain in the list after the list item has
|
|
* been removed.
|
|
*
|
|
* \page listREMOVE_ITEM listREMOVE_ITEM
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listREMOVE_ITEM( pxItemToRemove ) \
|
|
{ \
|
|
/* The list item knows which list it is in. Obtain the list from the list \
|
|
* item. */ \
|
|
List_t * const pxList = ( pxItemToRemove )->pxContainer; \
|
|
\
|
|
( pxItemToRemove )->pxNext->pxPrevious = ( pxItemToRemove )->pxPrevious; \
|
|
( pxItemToRemove )->pxPrevious->pxNext = ( pxItemToRemove )->pxNext; \
|
|
/* Make sure the index is left pointing to a valid item. */ \
|
|
if( pxList->pxIndex == ( pxItemToRemove ) ) \
|
|
{ \
|
|
pxList->pxIndex = ( pxItemToRemove )->pxPrevious; \
|
|
} \
|
|
\
|
|
( pxItemToRemove )->pxContainer = NULL; \
|
|
( pxList->uxNumberOfItems )--; \
|
|
}
|
|
|
|
/*
|
|
* Inline version of vListInsertEnd() to provide slight optimisation for
|
|
* xTaskIncrementTick().
|
|
*
|
|
* Insert a list item into a list. The item will be inserted in a position
|
|
* such that it will be the last item within the list returned by multiple
|
|
* calls to listGET_OWNER_OF_NEXT_ENTRY.
|
|
*
|
|
* The list member pxIndex is used to walk through a list. Calling
|
|
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
|
|
* Placing an item in a list using vListInsertEnd effectively places the item
|
|
* in the list position pointed to by pxIndex. This means that every other
|
|
* item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
|
|
* the pxIndex parameter again points to the item being inserted.
|
|
*
|
|
* @param pxList The list into which the item is to be inserted.
|
|
*
|
|
* @param pxNewListItem The list item to be inserted into the list.
|
|
*
|
|
* \page listINSERT_END listINSERT_END
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listINSERT_END( pxList, 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; \
|
|
\
|
|
pxIndex->pxPrevious->pxNext = ( pxNewListItem ); \
|
|
pxIndex->pxPrevious = ( pxNewListItem ); \
|
|
\
|
|
/* Remember which list the item is in. */ \
|
|
( pxNewListItem )->pxContainer = ( pxList ); \
|
|
\
|
|
( ( pxList )->uxNumberOfItems )++; \
|
|
}
|
|
|
|
/*
|
|
* Access function to obtain the owner of the first entry in a list. Lists
|
|
* are normally sorted in ascending item value order.
|
|
*
|
|
* This function returns the pxOwner member of the first item in the list.
|
|
* The pxOwner parameter of a list item is a pointer to the object that owns
|
|
* the list item. In the scheduler this is normally a task control block.
|
|
* The pxOwner parameter effectively creates a two way link between the list
|
|
* item and its owner.
|
|
*
|
|
* @param pxList The list from which the owner of the head item is to be
|
|
* returned.
|
|
*
|
|
* \page listGET_OWNER_OF_HEAD_ENTRY listGET_OWNER_OF_HEAD_ENTRY
|
|
* \ingroup LinkedList
|
|
*/
|
|
#define listGET_OWNER_OF_HEAD_ENTRY( pxList ) ( ( &( ( pxList )->xListEnd ) )->pxNext->pvOwner )
|
|
|
|
/*
|
|
* Check to see if a list item is within a list. The list item maintains a
|
|
* "container" pointer that points to the list it is in. All this macro does
|
|
* is check to see if the container and the list match.
|
|
*
|
|
* @param pxList The list we want to know if the list item is within.
|
|
* @param pxListItem The list item we want to know if is in the list.
|
|
* @return pdTRUE if the list item is in the list, otherwise pdFALSE.
|
|
*/
|
|
#define listIS_CONTAINED_WITHIN( pxList, pxListItem ) ( ( ( pxListItem )->pxContainer == ( pxList ) ) ? ( pdTRUE ) : ( pdFALSE ) )
|
|
|
|
/*
|
|
* Return the list a list item is contained within (referenced from).
|
|
*
|
|
* @param pxListItem The list item being queried.
|
|
* @return A pointer to the List_t object that references the pxListItem
|
|
*/
|
|
#define listLIST_ITEM_CONTAINER( pxListItem ) ( ( pxListItem )->pxContainer )
|
|
|
|
/*
|
|
* This provides a crude means of knowing if a list has been initialised, as
|
|
* pxList->xListEnd.xItemValue is set to portMAX_DELAY by the vListInitialise()
|
|
* function.
|
|
*/
|
|
#define listLIST_IS_INITIALISED( pxList ) ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )
|
|
|
|
/*
|
|
* Must be called before a list is used! This initialises all the members
|
|
* of the list structure and inserts the xListEnd item into the list as a
|
|
* marker to the back of the list.
|
|
*
|
|
* @param pxList Pointer to the list being initialised.
|
|
*
|
|
* \page vListInitialise vListInitialise
|
|
* \ingroup LinkedList
|
|
*/
|
|
void vListInitialise( List_t * const pxList ) PRIVILEGED_FUNCTION;
|
|
|
|
/*
|
|
* Must be called before a list item is used. This sets the list container to
|
|
* null so the item does not think that it is already contained in a list.
|
|
*
|
|
* @param pxItem Pointer to the list item being initialised.
|
|
*
|
|
* \page vListInitialiseItem vListInitialiseItem
|
|
* \ingroup LinkedList
|
|
*/
|
|
void vListInitialiseItem( ListItem_t * const pxItem ) PRIVILEGED_FUNCTION;
|
|
|
|
/*
|
|
* Insert a list item into a list. The item will be inserted into the list in
|
|
* a position determined by its item value (ascending item value order).
|
|
*
|
|
* @param pxList The list into which the item is to be inserted.
|
|
*
|
|
* @param pxNewListItem The item that is to be placed in the list.
|
|
*
|
|
* \page vListInsert vListInsert
|
|
* \ingroup LinkedList
|
|
*/
|
|
void vListInsert( List_t * const pxList,
|
|
ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
|
|
|
|
/*
|
|
* Insert a list item into a list. The item will be inserted in a position
|
|
* such that it will be the last item within the list returned by multiple
|
|
* calls to listGET_OWNER_OF_NEXT_ENTRY.
|
|
*
|
|
* The list member pxIndex is used to walk through a list. Calling
|
|
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
|
|
* Placing an item in a list using vListInsertEnd effectively places the item
|
|
* in the list position pointed to by pxIndex. This means that every other
|
|
* item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
|
|
* the pxIndex parameter again points to the item being inserted.
|
|
*
|
|
* @param pxList The list into which the item is to be inserted.
|
|
*
|
|
* @param pxNewListItem The list item to be inserted into the list.
|
|
*
|
|
* \page vListInsertEnd vListInsertEnd
|
|
* \ingroup LinkedList
|
|
*/
|
|
void vListInsertEnd( List_t * const pxList,
|
|
ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
|
|
|
|
/*
|
|
* Remove an item from a list. The list item has a pointer to the list that
|
|
* it is in, so only the list item need be passed into the function.
|
|
*
|
|
* @param uxListRemove The item to be removed. The item will remove itself from
|
|
* the list pointed to by it's pxContainer parameter.
|
|
*
|
|
* @return The number of items that remain in the list after the list item has
|
|
* been removed.
|
|
*
|
|
* \page uxListRemove uxListRemove
|
|
* \ingroup LinkedList
|
|
*/
|
|
UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove ) PRIVILEGED_FUNCTION;
|
|
|
|
/* *INDENT-OFF* */
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
/* *INDENT-ON* */
|
|
|
|
#endif /* ifndef LIST_H */
|