1 /*
2 * FreeRTOS Kernel V10.6.2
3 * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
4 *
5 * SPDX-License-Identifier: MIT
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy of
8 * this software and associated documentation files (the "Software"), to deal in
9 * the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
11 * the Software, and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
20 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * https://www.FreeRTOS.org
25 * https://github.com/FreeRTOS
26 *
27 */
28
29 /*
30 * A sample implementation of pvPortMalloc() that allows the heap to be defined
31 * across multiple non-contigous blocks and combines (coalescences) adjacent
32 * memory blocks as they are freed.
33 *
34 * See heap_1.c, heap_2.c, heap_3.c and heap_4.c for alternative
35 * implementations, and the memory management pages of https://www.FreeRTOS.org
36 * for more information.
37 *
38 * Usage notes:
39 *
40 * vPortDefineHeapRegions() ***must*** be called before pvPortMalloc().
41 * pvPortMalloc() will be called if any task objects (tasks, queues, event
42 * groups, etc.) are created, therefore vPortDefineHeapRegions() ***must*** be
43 * called before any other objects are defined.
44 *
45 * vPortDefineHeapRegions() takes a single parameter. The parameter is an array
46 * of HeapRegion_t structures. HeapRegion_t is defined in portable.h as
47 *
48 * typedef struct HeapRegion
49 * {
50 * uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.
51 * size_t xSizeInBytes; << Size of the block of memory.
52 * } HeapRegion_t;
53 *
54 * The array is terminated using a NULL zero sized region definition, and the
55 * memory regions defined in the array ***must*** appear in address order from
56 * low address to high address. So the following is a valid example of how
57 * to use the function.
58 *
59 * HeapRegion_t xHeapRegions[] =
60 * {
61 * { ( uint8_t * ) 0x80000000UL, 0x10000 }, << Defines a block of 0x10000 bytes starting at address 0x80000000
62 * { ( uint8_t * ) 0x90000000UL, 0xa0000 }, << Defines a block of 0xa0000 bytes starting at address of 0x90000000
63 * { NULL, 0 } << Terminates the array.
64 * };
65 *
66 * vPortDefineHeapRegions( xHeapRegions ); << Pass the array into vPortDefineHeapRegions().
67 *
68 * Note 0x80000000 is the lower address so appears in the array first.
69 *
70 */
71 #include <stdlib.h>
72 #include <string.h>
73
74 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
75 * all the API functions to use the MPU wrappers. That should only be done when
76 * task.h is included from an application file. */
77 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
78
79 #include "FreeRTOS.h"
80 #include "task.h"
81
82 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
83
84 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
85 #error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
86 #endif
87
88 #ifndef configHEAP_CLEAR_MEMORY_ON_FREE
89 #define configHEAP_CLEAR_MEMORY_ON_FREE 0
90 #endif
91
92 /* Block sizes must not get too small. */
93 #define heapMINIMUM_BLOCK_SIZE ( ( size_t ) ( xHeapStructSize << 1 ) )
94
95 /* Assumes 8bit bytes! */
96 #define heapBITS_PER_BYTE ( ( size_t ) 8 )
97
98 /* Max value that fits in a size_t type. */
99 #define heapSIZE_MAX ( ~( ( size_t ) 0 ) )
100
101 /* Check if multiplying a and b will result in overflow. */
102 #define heapMULTIPLY_WILL_OVERFLOW( a, b ) ( ( ( a ) > 0 ) && ( ( b ) > ( heapSIZE_MAX / ( a ) ) ) )
103
104 /* Check if adding a and b will result in overflow. */
105 #define heapADD_WILL_OVERFLOW( a, b ) ( ( a ) > ( heapSIZE_MAX - ( b ) ) )
106
107 /* MSB of the xBlockSize member of an BlockLink_t structure is used to track
108 * the allocation status of a block. When MSB of the xBlockSize member of
109 * an BlockLink_t structure is set then the block belongs to the application.
110 * When the bit is free the block is still part of the free heap space. */
111 #define heapBLOCK_ALLOCATED_BITMASK ( ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 ) )
112 #define heapBLOCK_SIZE_IS_VALID( xBlockSize ) ( ( ( xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) == 0 )
113 #define heapBLOCK_IS_ALLOCATED( pxBlock ) ( ( ( pxBlock->xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) != 0 )
114 #define heapALLOCATE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) |= heapBLOCK_ALLOCATED_BITMASK )
115 #define heapFREE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) &= ~heapBLOCK_ALLOCATED_BITMASK )
116
117 /*-----------------------------------------------------------*/
118
119 /* Define the linked list structure. This is used to link free blocks in order
120 * of their memory address. */
121 typedef struct A_BLOCK_LINK
122 {
123 struct A_BLOCK_LINK * pxNextFreeBlock; /*<< The next free block in the list. */
124 size_t xBlockSize; /*<< The size of the free block. */
125 } BlockLink_t;
126
127 /*-----------------------------------------------------------*/
128
129 /*
130 * Inserts a block of memory that is being freed into the correct position in
131 * the list of free memory blocks. The block being freed will be merged with
132 * the block in front it and/or the block behind it if the memory blocks are
133 * adjacent to each other.
134 */
135 static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert );
136
137 /*-----------------------------------------------------------*/
138
139 /* The size of the structure placed at the beginning of each allocated memory
140 * block must by correctly byte aligned. */
141 static const size_t xHeapStructSize = ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
142
143 /* Create a couple of list links to mark the start and end of the list. */
144 static BlockLink_t xStart;
145 static BlockLink_t * pxEnd = NULL;
146
147 /* Keeps track of the number of calls to allocate and free memory as well as the
148 * number of free bytes remaining, but says nothing about fragmentation. */
149 static size_t xFreeBytesRemaining = 0U;
150 static size_t xMinimumEverFreeBytesRemaining = 0U;
151 static size_t xNumberOfSuccessfulAllocations = 0;
152 static size_t xNumberOfSuccessfulFrees = 0;
153
154 /*-----------------------------------------------------------*/
155
pvPortMalloc(size_t xWantedSize)156 void * pvPortMalloc( size_t xWantedSize )
157 {
158 BlockLink_t * pxBlock;
159 BlockLink_t * pxPreviousBlock;
160 BlockLink_t * pxNewBlockLink;
161 void * pvReturn = NULL;
162 size_t xAdditionalRequiredSize;
163
164 /* The heap must be initialised before the first call to
165 * prvPortMalloc(). */
166 configASSERT( pxEnd );
167
168 vTaskSuspendAll();
169 {
170 if( xWantedSize > 0 )
171 {
172 /* The wanted size must be increased so it can contain a BlockLink_t
173 * structure in addition to the requested amount of bytes. */
174 if( heapADD_WILL_OVERFLOW( xWantedSize, xHeapStructSize ) == 0 )
175 {
176 xWantedSize += xHeapStructSize;
177
178 /* Ensure that blocks are always aligned to the required number
179 * of bytes. */
180 if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
181 {
182 /* Byte alignment required. */
183 xAdditionalRequiredSize = portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK );
184
185 if( heapADD_WILL_OVERFLOW( xWantedSize, xAdditionalRequiredSize ) == 0 )
186 {
187 xWantedSize += xAdditionalRequiredSize;
188 }
189 else
190 {
191 xWantedSize = 0;
192 }
193 }
194 else
195 {
196 mtCOVERAGE_TEST_MARKER();
197 }
198 }
199 else
200 {
201 xWantedSize = 0;
202 }
203 }
204 else
205 {
206 mtCOVERAGE_TEST_MARKER();
207 }
208
209 /* Check the block size we are trying to allocate is not so large that the
210 * top bit is set. The top bit of the block size member of the BlockLink_t
211 * structure is used to determine who owns the block - the application or
212 * the kernel, so it must be free. */
213 if( heapBLOCK_SIZE_IS_VALID( xWantedSize ) != 0 )
214 {
215 if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
216 {
217 /* Traverse the list from the start (lowest address) block until
218 * one of adequate size is found. */
219 pxPreviousBlock = &xStart;
220 pxBlock = xStart.pxNextFreeBlock;
221
222 while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
223 {
224 pxPreviousBlock = pxBlock;
225 pxBlock = pxBlock->pxNextFreeBlock;
226 }
227
228 /* If the end marker was reached then a block of adequate size
229 * was not found. */
230 if( pxBlock != pxEnd )
231 {
232 /* Return the memory space pointed to - jumping over the
233 * BlockLink_t structure at its start. */
234 pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );
235
236 /* This block is being returned for use so must be taken out
237 * of the list of free blocks. */
238 pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
239
240 /* If the block is larger than required it can be split into
241 * two. */
242 if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
243 {
244 /* This block is to be split into two. Create a new
245 * block following the number of bytes requested. The void
246 * cast is used to prevent byte alignment warnings from the
247 * compiler. */
248 pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
249
250 /* Calculate the sizes of two blocks split from the
251 * single block. */
252 pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
253 pxBlock->xBlockSize = xWantedSize;
254
255 /* Insert the new block into the list of free blocks. */
256 prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );
257 }
258 else
259 {
260 mtCOVERAGE_TEST_MARKER();
261 }
262
263 xFreeBytesRemaining -= pxBlock->xBlockSize;
264
265 if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
266 {
267 xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
268 }
269 else
270 {
271 mtCOVERAGE_TEST_MARKER();
272 }
273
274 /* The block is being returned - it is allocated and owned
275 * by the application and has no "next" block. */
276 heapALLOCATE_BLOCK( pxBlock );
277 pxBlock->pxNextFreeBlock = NULL;
278 xNumberOfSuccessfulAllocations++;
279 }
280 else
281 {
282 mtCOVERAGE_TEST_MARKER();
283 }
284 }
285 else
286 {
287 mtCOVERAGE_TEST_MARKER();
288 }
289 }
290 else
291 {
292 mtCOVERAGE_TEST_MARKER();
293 }
294
295 traceMALLOC( pvReturn, xWantedSize );
296 }
297 ( void ) xTaskResumeAll();
298
299 #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
300 {
301 if( pvReturn == NULL )
302 {
303 vApplicationMallocFailedHook();
304 }
305 else
306 {
307 mtCOVERAGE_TEST_MARKER();
308 }
309 }
310 #endif /* if ( configUSE_MALLOC_FAILED_HOOK == 1 ) */
311
312 return pvReturn;
313 }
314 /*-----------------------------------------------------------*/
315
vPortFree(void * pv)316 void vPortFree( void * pv )
317 {
318 uint8_t * puc = ( uint8_t * ) pv;
319 BlockLink_t * pxLink;
320
321 if( pv != NULL )
322 {
323 /* The memory being freed will have an BlockLink_t structure immediately
324 * before it. */
325 puc -= xHeapStructSize;
326
327 /* This casting is to keep the compiler from issuing warnings. */
328 pxLink = ( void * ) puc;
329
330 configASSERT( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 );
331 configASSERT( pxLink->pxNextFreeBlock == NULL );
332
333 if( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 )
334 {
335 if( pxLink->pxNextFreeBlock == NULL )
336 {
337 /* The block is being returned to the heap - it is no longer
338 * allocated. */
339 heapFREE_BLOCK( pxLink );
340 #if ( configHEAP_CLEAR_MEMORY_ON_FREE == 1 )
341 {
342 ( void ) memset( puc + xHeapStructSize, 0, pxLink->xBlockSize - xHeapStructSize );
343 }
344 #endif
345
346 vTaskSuspendAll();
347 {
348 /* Add this block to the list of free blocks. */
349 xFreeBytesRemaining += pxLink->xBlockSize;
350 traceFREE( pv, pxLink->xBlockSize );
351 prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
352 xNumberOfSuccessfulFrees++;
353 }
354 ( void ) xTaskResumeAll();
355 }
356 else
357 {
358 mtCOVERAGE_TEST_MARKER();
359 }
360 }
361 else
362 {
363 mtCOVERAGE_TEST_MARKER();
364 }
365 }
366 }
367 /*-----------------------------------------------------------*/
368
xPortGetFreeHeapSize(void)369 size_t xPortGetFreeHeapSize( void )
370 {
371 return xFreeBytesRemaining;
372 }
373 /*-----------------------------------------------------------*/
374
xPortGetMinimumEverFreeHeapSize(void)375 size_t xPortGetMinimumEverFreeHeapSize( void )
376 {
377 return xMinimumEverFreeBytesRemaining;
378 }
379 /*-----------------------------------------------------------*/
380
pvPortCalloc(size_t xNum,size_t xSize)381 void * pvPortCalloc( size_t xNum,
382 size_t xSize )
383 {
384 void * pv = NULL;
385
386 if( heapMULTIPLY_WILL_OVERFLOW( xNum, xSize ) == 0 )
387 {
388 pv = pvPortMalloc( xNum * xSize );
389
390 if( pv != NULL )
391 {
392 ( void ) memset( pv, 0, xNum * xSize );
393 }
394 }
395
396 return pv;
397 }
398 /*-----------------------------------------------------------*/
399
prvInsertBlockIntoFreeList(BlockLink_t * pxBlockToInsert)400 static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert )
401 {
402 BlockLink_t * pxIterator;
403 uint8_t * puc;
404
405 /* Iterate through the list until a block is found that has a higher address
406 * than the block being inserted. */
407 for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
408 {
409 /* Nothing to do here, just iterate to the right position. */
410 }
411
412 /* Do the block being inserted, and the block it is being inserted after
413 * make a contiguous block of memory? */
414 puc = ( uint8_t * ) pxIterator;
415
416 if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
417 {
418 pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
419 pxBlockToInsert = pxIterator;
420 }
421 else
422 {
423 mtCOVERAGE_TEST_MARKER();
424 }
425
426 /* Do the block being inserted, and the block it is being inserted before
427 * make a contiguous block of memory? */
428 puc = ( uint8_t * ) pxBlockToInsert;
429
430 if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
431 {
432 if( pxIterator->pxNextFreeBlock != pxEnd )
433 {
434 /* Form one big block from the two blocks. */
435 pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
436 pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
437 }
438 else
439 {
440 pxBlockToInsert->pxNextFreeBlock = pxEnd;
441 }
442 }
443 else
444 {
445 pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
446 }
447
448 /* If the block being inserted plugged a gab, so was merged with the block
449 * before and the block after, then it's pxNextFreeBlock pointer will have
450 * already been set, and should not be set here as that would make it point
451 * to itself. */
452 if( pxIterator != pxBlockToInsert )
453 {
454 pxIterator->pxNextFreeBlock = pxBlockToInsert;
455 }
456 else
457 {
458 mtCOVERAGE_TEST_MARKER();
459 }
460 }
461 /*-----------------------------------------------------------*/
462
vPortDefineHeapRegions(const HeapRegion_t * const pxHeapRegions)463 void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions )
464 {
465 BlockLink_t * pxFirstFreeBlockInRegion = NULL;
466 BlockLink_t * pxPreviousFreeBlock;
467 portPOINTER_SIZE_TYPE xAlignedHeap;
468 size_t xTotalRegionSize, xTotalHeapSize = 0;
469 BaseType_t xDefinedRegions = 0;
470 portPOINTER_SIZE_TYPE xAddress;
471 const HeapRegion_t * pxHeapRegion;
472
473 /* Can only call once! */
474 configASSERT( pxEnd == NULL );
475
476 pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );
477
478 while( pxHeapRegion->xSizeInBytes > 0 )
479 {
480 xTotalRegionSize = pxHeapRegion->xSizeInBytes;
481
482 /* Ensure the heap region starts on a correctly aligned boundary. */
483 xAddress = ( portPOINTER_SIZE_TYPE ) pxHeapRegion->pucStartAddress;
484
485 if( ( xAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
486 {
487 xAddress += ( portBYTE_ALIGNMENT - 1 );
488 xAddress &= ~portBYTE_ALIGNMENT_MASK;
489
490 /* Adjust the size for the bytes lost to alignment. */
491 xTotalRegionSize -= ( size_t ) ( xAddress - ( portPOINTER_SIZE_TYPE ) pxHeapRegion->pucStartAddress );
492 }
493
494 xAlignedHeap = xAddress;
495
496 /* Set xStart if it has not already been set. */
497 if( xDefinedRegions == 0 )
498 {
499 /* xStart is used to hold a pointer to the first item in the list of
500 * free blocks. The void cast is used to prevent compiler warnings. */
501 xStart.pxNextFreeBlock = ( BlockLink_t * ) xAlignedHeap;
502 xStart.xBlockSize = ( size_t ) 0;
503 }
504 else
505 {
506 /* Should only get here if one region has already been added to the
507 * heap. */
508 configASSERT( pxEnd != NULL );
509
510 /* Check blocks are passed in with increasing start addresses. */
511 configASSERT( xAddress > ( size_t ) pxEnd );
512 }
513
514 /* Remember the location of the end marker in the previous region, if
515 * any. */
516 pxPreviousFreeBlock = pxEnd;
517
518 /* pxEnd is used to mark the end of the list of free blocks and is
519 * inserted at the end of the region space. */
520 xAddress = xAlignedHeap + xTotalRegionSize;
521 xAddress -= xHeapStructSize;
522 xAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
523 pxEnd = ( BlockLink_t * ) xAddress;
524 pxEnd->xBlockSize = 0;
525 pxEnd->pxNextFreeBlock = NULL;
526
527 /* To start with there is a single free block in this region that is
528 * sized to take up the entire heap region minus the space taken by the
529 * free block structure. */
530 pxFirstFreeBlockInRegion = ( BlockLink_t * ) xAlignedHeap;
531 pxFirstFreeBlockInRegion->xBlockSize = ( size_t ) ( xAddress - ( portPOINTER_SIZE_TYPE ) pxFirstFreeBlockInRegion );
532 pxFirstFreeBlockInRegion->pxNextFreeBlock = pxEnd;
533
534 /* If this is not the first region that makes up the entire heap space
535 * then link the previous region to this region. */
536 if( pxPreviousFreeBlock != NULL )
537 {
538 pxPreviousFreeBlock->pxNextFreeBlock = pxFirstFreeBlockInRegion;
539 }
540
541 xTotalHeapSize += pxFirstFreeBlockInRegion->xBlockSize;
542
543 /* Move onto the next HeapRegion_t structure. */
544 xDefinedRegions++;
545 pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );
546 }
547
548 xMinimumEverFreeBytesRemaining = xTotalHeapSize;
549 xFreeBytesRemaining = xTotalHeapSize;
550
551 /* Check something was actually defined before it is accessed. */
552 configASSERT( xTotalHeapSize );
553 }
554 /*-----------------------------------------------------------*/
555
vPortGetHeapStats(HeapStats_t * pxHeapStats)556 void vPortGetHeapStats( HeapStats_t * pxHeapStats )
557 {
558 BlockLink_t * pxBlock;
559 size_t xBlocks = 0, xMaxSize = 0, xMinSize = portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
560
561 vTaskSuspendAll();
562 {
563 pxBlock = xStart.pxNextFreeBlock;
564
565 /* pxBlock will be NULL if the heap has not been initialised. The heap
566 * is initialised automatically when the first allocation is made. */
567 if( pxBlock != NULL )
568 {
569 while( pxBlock != pxEnd )
570 {
571 /* Increment the number of blocks and record the largest block seen
572 * so far. */
573 xBlocks++;
574
575 if( pxBlock->xBlockSize > xMaxSize )
576 {
577 xMaxSize = pxBlock->xBlockSize;
578 }
579
580 /* Heap five will have a zero sized block at the end of each
581 * each region - the block is only used to link to the next
582 * heap region so it not a real block. */
583 if( pxBlock->xBlockSize != 0 )
584 {
585 if( pxBlock->xBlockSize < xMinSize )
586 {
587 xMinSize = pxBlock->xBlockSize;
588 }
589 }
590
591 /* Move to the next block in the chain until the last block is
592 * reached. */
593 pxBlock = pxBlock->pxNextFreeBlock;
594 }
595 }
596 }
597 ( void ) xTaskResumeAll();
598
599 pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize;
600 pxHeapStats->xSizeOfSmallestFreeBlockInBytes = xMinSize;
601 pxHeapStats->xNumberOfFreeBlocks = xBlocks;
602
603 taskENTER_CRITICAL();
604 {
605 pxHeapStats->xAvailableHeapSpaceInBytes = xFreeBytesRemaining;
606 pxHeapStats->xNumberOfSuccessfulAllocations = xNumberOfSuccessfulAllocations;
607 pxHeapStats->xNumberOfSuccessfulFrees = xNumberOfSuccessfulFrees;
608 pxHeapStats->xMinimumEverFreeBytesRemaining = xMinimumEverFreeBytesRemaining;
609 }
610 taskEXIT_CRITICAL();
611 }
612 /*-----------------------------------------------------------*/
613
