2 * FreeRTOS Kernel V10.2.0
\r
3 * Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
\r
5 * Permission is hereby granted, free of charge, to any person obtaining a copy of
\r
6 * this software and associated documentation files (the "Software"), to deal in
\r
7 * the Software without restriction, including without limitation the rights to
\r
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
\r
9 * the Software, and to permit persons to whom the Software is furnished to do so,
\r
10 * subject to the following conditions:
\r
12 * The above copyright notice and this permission notice shall be included in all
\r
13 * copies or substantial portions of the Software.
\r
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
\r
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
\r
17 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
\r
18 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
\r
19 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
\r
20 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\r
22 * http://www.FreeRTOS.org
\r
23 * http://aws.amazon.com/freertos
\r
25 * 1 tab == 4 spaces!
\r
28 /* Standard includes. */
\r
31 /* Secure context heap includes. */
\r
32 #include "secure_heap.h"
\r
34 /* Secure port macros. */
\r
35 #include "secure_port_macros.h"
\r
38 * @brief Total heap size.
\r
40 #define secureconfigTOTAL_HEAP_SIZE ( ( ( size_t ) ( 10 * 1024 ) ) )
\r
42 /* No test marker by default. */
\r
43 #ifndef mtCOVERAGE_TEST_MARKER
\r
44 #define mtCOVERAGE_TEST_MARKER()
\r
47 /* No tracing by default. */
\r
49 #define traceMALLOC( pvReturn, xWantedSize )
\r
52 /* No tracing by default. */
\r
54 #define traceFREE( pv, xBlockSize )
\r
57 /* Block sizes must not get too small. */
\r
58 #define secureheapMINIMUM_BLOCK_SIZE ( ( size_t ) ( xHeapStructSize << 1 ) )
\r
60 /* Assumes 8bit bytes! */
\r
61 #define secureheapBITS_PER_BYTE ( ( size_t ) 8 )
\r
62 /*-----------------------------------------------------------*/
\r
64 /* Allocate the memory for the heap. */
\r
65 #if( configAPPLICATION_ALLOCATED_HEAP == 1 )
\r
66 /* The application writer has already defined the array used for the RTOS
\r
67 * heap - probably so it can be placed in a special segment or address. */
\r
68 extern uint8_t ucHeap[ secureconfigTOTAL_HEAP_SIZE ];
\r
69 #else /* configAPPLICATION_ALLOCATED_HEAP */
\r
70 static uint8_t ucHeap[ secureconfigTOTAL_HEAP_SIZE ];
\r
71 #endif /* configAPPLICATION_ALLOCATED_HEAP */
\r
74 * @brief The linked list structure.
\r
76 * This is used to link free blocks in order of their memory address.
\r
78 typedef struct A_BLOCK_LINK
\r
80 struct A_BLOCK_LINK *pxNextFreeBlock; /**< The next free block in the list. */
\r
81 size_t xBlockSize; /**< The size of the free block. */
\r
83 /*-----------------------------------------------------------*/
\r
86 * @brief Called automatically to setup the required heap structures the first
\r
87 * time pvPortMalloc() is called.
\r
89 static void prvHeapInit( void );
\r
92 * @brief Inserts a block of memory that is being freed into the correct
\r
93 * position in the list of free memory blocks.
\r
95 * The block being freed will be merged with the block in front it and/or the
\r
96 * block behind it if the memory blocks are adjacent to each other.
\r
98 * @param[in] pxBlockToInsert The block being freed.
\r
100 static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert );
\r
101 /*-----------------------------------------------------------*/
\r
104 * @brief The size of the structure placed at the beginning of each allocated
\r
105 * memory block must by correctly byte aligned.
\r
107 static const size_t xHeapStructSize = ( sizeof( BlockLink_t ) + ( ( size_t ) ( secureportBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) secureportBYTE_ALIGNMENT_MASK );
\r
110 * @brief Create a couple of list links to mark the start and end of the list.
\r
112 static BlockLink_t xStart, *pxEnd = NULL;
\r
115 * @brief Keeps track of the number of free bytes remaining, but says nothing
\r
116 * about fragmentation.
\r
118 static size_t xFreeBytesRemaining = 0U;
\r
119 static size_t xMinimumEverFreeBytesRemaining = 0U;
\r
122 * @brief Gets set to the top bit of an size_t type.
\r
124 * When this bit in the xBlockSize member of an BlockLink_t structure is set
\r
125 * then the block belongs to the application. When the bit is free the block is
\r
126 * still part of the free heap space.
\r
128 static size_t xBlockAllocatedBit = 0;
\r
129 /*-----------------------------------------------------------*/
\r
131 static void prvHeapInit( void )
\r
133 BlockLink_t *pxFirstFreeBlock;
\r
134 uint8_t *pucAlignedHeap;
\r
136 size_t xTotalHeapSize = secureconfigTOTAL_HEAP_SIZE;
\r
138 /* Ensure the heap starts on a correctly aligned boundary. */
\r
139 uxAddress = ( size_t ) ucHeap;
\r
141 if( ( uxAddress & secureportBYTE_ALIGNMENT_MASK ) != 0 )
\r
143 uxAddress += ( secureportBYTE_ALIGNMENT - 1 );
\r
144 uxAddress &= ~( ( size_t ) secureportBYTE_ALIGNMENT_MASK );
\r
145 xTotalHeapSize -= uxAddress - ( size_t ) ucHeap;
\r
148 pucAlignedHeap = ( uint8_t * ) uxAddress;
\r
150 /* xStart is used to hold a pointer to the first item in the list of free
\r
151 * blocks. The void cast is used to prevent compiler warnings. */
\r
152 xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
\r
153 xStart.xBlockSize = ( size_t ) 0;
\r
155 /* pxEnd is used to mark the end of the list of free blocks and is inserted
\r
156 * at the end of the heap space. */
\r
157 uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize;
\r
158 uxAddress -= xHeapStructSize;
\r
159 uxAddress &= ~( ( size_t ) secureportBYTE_ALIGNMENT_MASK );
\r
160 pxEnd = ( void * ) uxAddress;
\r
161 pxEnd->xBlockSize = 0;
\r
162 pxEnd->pxNextFreeBlock = NULL;
\r
164 /* To start with there is a single free block that is sized to take up the
\r
165 * entire heap space, minus the space taken by pxEnd. */
\r
166 pxFirstFreeBlock = ( void * ) pucAlignedHeap;
\r
167 pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock;
\r
168 pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
\r
170 /* Only one block exists - and it covers the entire usable heap space. */
\r
171 xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
\r
172 xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
\r
174 /* Work out the position of the top bit in a size_t variable. */
\r
175 xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * secureheapBITS_PER_BYTE ) - 1 );
\r
177 /*-----------------------------------------------------------*/
\r
179 static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )
\r
181 BlockLink_t *pxIterator;
\r
184 /* Iterate through the list until a block is found that has a higher address
\r
185 * than the block being inserted. */
\r
186 for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
\r
188 /* Nothing to do here, just iterate to the right position. */
\r
191 /* Do the block being inserted, and the block it is being inserted after
\r
192 * make a contiguous block of memory? */
\r
193 puc = ( uint8_t * ) pxIterator;
\r
194 if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
\r
196 pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
\r
197 pxBlockToInsert = pxIterator;
\r
201 mtCOVERAGE_TEST_MARKER();
\r
204 /* Do the block being inserted, and the block it is being inserted before
\r
205 * make a contiguous block of memory? */
\r
206 puc = ( uint8_t * ) pxBlockToInsert;
\r
207 if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
\r
209 if( pxIterator->pxNextFreeBlock != pxEnd )
\r
211 /* Form one big block from the two blocks. */
\r
212 pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
\r
213 pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
\r
217 pxBlockToInsert->pxNextFreeBlock = pxEnd;
\r
222 pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
\r
225 /* If the block being inserted plugged a gab, so was merged with the block
\r
226 * before and the block after, then it's pxNextFreeBlock pointer will have
\r
227 * already been set, and should not be set here as that would make it point
\r
229 if( pxIterator != pxBlockToInsert )
\r
231 pxIterator->pxNextFreeBlock = pxBlockToInsert;
\r
235 mtCOVERAGE_TEST_MARKER();
\r
238 /*-----------------------------------------------------------*/
\r
240 void *pvPortMalloc( size_t xWantedSize )
\r
242 BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
\r
243 void *pvReturn = NULL;
\r
245 /* If this is the first call to malloc then the heap will require
\r
246 * initialisation to setup the list of free blocks. */
\r
247 if( pxEnd == NULL )
\r
253 mtCOVERAGE_TEST_MARKER();
\r
256 /* Check the requested block size is not so large that the top bit is set.
\r
257 * The top bit of the block size member of the BlockLink_t structure is used
\r
258 * to determine who owns the block - the application or the kernel, so it
\r
260 if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
\r
262 /* The wanted size is increased so it can contain a BlockLink_t
\r
263 * structure in addition to the requested amount of bytes. */
\r
264 if( xWantedSize > 0 )
\r
266 xWantedSize += xHeapStructSize;
\r
268 /* Ensure that blocks are always aligned to the required number of
\r
270 if( ( xWantedSize & secureportBYTE_ALIGNMENT_MASK ) != 0x00 )
\r
272 /* Byte alignment required. */
\r
273 xWantedSize += ( secureportBYTE_ALIGNMENT - ( xWantedSize & secureportBYTE_ALIGNMENT_MASK ) );
\r
274 secureportASSERT( ( xWantedSize & secureportBYTE_ALIGNMENT_MASK ) == 0 );
\r
278 mtCOVERAGE_TEST_MARKER();
\r
283 mtCOVERAGE_TEST_MARKER();
\r
286 if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
\r
288 /* Traverse the list from the start (lowest address) block until
\r
289 * one of adequate size is found. */
\r
290 pxPreviousBlock = &xStart;
\r
291 pxBlock = xStart.pxNextFreeBlock;
\r
292 while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
\r
294 pxPreviousBlock = pxBlock;
\r
295 pxBlock = pxBlock->pxNextFreeBlock;
\r
298 /* If the end marker was reached then a block of adequate size was
\r
300 if( pxBlock != pxEnd )
\r
302 /* Return the memory space pointed to - jumping over the
\r
303 * BlockLink_t structure at its start. */
\r
304 pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );
\r
306 /* This block is being returned for use so must be taken out
\r
307 * of the list of free blocks. */
\r
308 pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
\r
310 /* If the block is larger than required it can be split into
\r
312 if( ( pxBlock->xBlockSize - xWantedSize ) > secureheapMINIMUM_BLOCK_SIZE )
\r
314 /* This block is to be split into two. Create a new
\r
315 * block following the number of bytes requested. The void
\r
316 * cast is used to prevent byte alignment warnings from the
\r
318 pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
\r
319 secureportASSERT( ( ( ( size_t ) pxNewBlockLink ) & secureportBYTE_ALIGNMENT_MASK ) == 0 );
\r
321 /* Calculate the sizes of two blocks split from the single
\r
323 pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
\r
324 pxBlock->xBlockSize = xWantedSize;
\r
326 /* Insert the new block into the list of free blocks. */
\r
327 prvInsertBlockIntoFreeList( pxNewBlockLink );
\r
331 mtCOVERAGE_TEST_MARKER();
\r
334 xFreeBytesRemaining -= pxBlock->xBlockSize;
\r
336 if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
\r
338 xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
\r
342 mtCOVERAGE_TEST_MARKER();
\r
345 /* The block is being returned - it is allocated and owned by
\r
346 * the application and has no "next" block. */
\r
347 pxBlock->xBlockSize |= xBlockAllocatedBit;
\r
348 pxBlock->pxNextFreeBlock = NULL;
\r
352 mtCOVERAGE_TEST_MARKER();
\r
357 mtCOVERAGE_TEST_MARKER();
\r
362 mtCOVERAGE_TEST_MARKER();
\r
365 traceMALLOC( pvReturn, xWantedSize );
\r
367 #if( secureconfigUSE_MALLOC_FAILED_HOOK == 1 )
\r
369 if( pvReturn == NULL )
\r
371 extern void vApplicationMallocFailedHook( void );
\r
372 vApplicationMallocFailedHook();
\r
376 mtCOVERAGE_TEST_MARKER();
\r
381 secureportASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) secureportBYTE_ALIGNMENT_MASK ) == 0 );
\r
384 /*-----------------------------------------------------------*/
\r
386 void vPortFree( void *pv )
\r
388 uint8_t *puc = ( uint8_t * ) pv;
\r
389 BlockLink_t *pxLink;
\r
393 /* The memory being freed will have an BlockLink_t structure immediately
\r
395 puc -= xHeapStructSize;
\r
397 /* This casting is to keep the compiler from issuing warnings. */
\r
398 pxLink = ( void * ) puc;
\r
400 /* Check the block is actually allocated. */
\r
401 secureportASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
\r
402 secureportASSERT( pxLink->pxNextFreeBlock == NULL );
\r
404 if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
\r
406 if( pxLink->pxNextFreeBlock == NULL )
\r
408 /* The block is being returned to the heap - it is no longer
\r
410 pxLink->xBlockSize &= ~xBlockAllocatedBit;
\r
412 secureportDISABLE_NON_SECURE_INTERRUPTS();
\r
414 /* Add this block to the list of free blocks. */
\r
415 xFreeBytesRemaining += pxLink->xBlockSize;
\r
416 traceFREE( pv, pxLink->xBlockSize );
\r
417 prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
\r
419 secureportENABLE_NON_SECURE_INTERRUPTS();
\r
423 mtCOVERAGE_TEST_MARKER();
\r
428 mtCOVERAGE_TEST_MARKER();
\r
432 /*-----------------------------------------------------------*/
\r
434 size_t xPortGetFreeHeapSize( void )
\r
436 return xFreeBytesRemaining;
\r
438 /*-----------------------------------------------------------*/
\r
440 size_t xPortGetMinimumEverFreeHeapSize( void )
\r
442 return xMinimumEverFreeBytesRemaining;
\r
444 /*-----------------------------------------------------------*/
\r
446 void vPortInitialiseBlocks( void )
\r
448 /* This just exists to keep the linker quiet. */
\r
450 /*-----------------------------------------------------------*/
\r