alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
de0990e58c
esp-idf/components/freertos/heap_idf.c

109 lines
3.4 KiB
C
Raw Normal View History

freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
/*
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
* SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
*
change(freertos/idf): Update version number, licenses, and sbom to v10.5.1 Following the upgrade to FreeRTOS kernel v10.5.1, this commit updates the version numbers, licenses, and SBOM files of FreeRTOS files to reflect v10.5.1. Note: - Updated licenses as v10.5.1 now uses SPDX format - Removed CVE-2021-43997 as it was fixed post v10.4.5
2023-10-08 15:30:04 -04:00
* SPDX-License-Identifier: Apache-2.0
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
*/
#include "sdkconfig.h"
/* This file implements the heap related functions that are called by FreeRTOS.
* ESP-IDF provides its own heap containing memory with different capabilities
* (see esp_heap_caps.h). Thus, this file maps a subset of the ESP-IDF heap to
* act as the FreeRTOS heap.
*
* All dynamic allocation done by FreeRTOS should be placed in internal 8-bit
* accessible RAM (i.e., using the MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT flags).
* This is due to the fact that FreeRTOS objects (e.g., task stacks, TCBs,
* queues etc) must be accessible even if the cache is disabled. Therefore, the
* heap that is made available to FreeRTOS for dynamic allocation is a subset of
* the ESP-IDF heap (where all MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT memory is
* made available to FreeRTOS for dynamic allocation).
*/
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
* all the API functions to use the MPU wrappers. That should only be done when
* task.h is included from an application file. */
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
#include "FreeRTOS.h"
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
#endif
#include "esp_heap_caps.h"
#if !CONFIG_IDF_TARGET_LINUX
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
/* Memory util functions are not implemented in the Linux simulator */
#include "esp_memory_utils.h"
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
#endif /* CONFIG_IDF_TARGET_LINUX */
#define portFREERTOS_HEAP_CAPS ( MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT )
/*-----------------------------------------------------------*/
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
void * pvPortMalloc(size_t xWantedSize)
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
{
void * pvReturn = NULL;
/* All dynamic allocation done by FreeRTOS goes through this function. If
* users need to allocate FreeRTOS objects into external RAM, they should
* use the "static" equivalents of FreeRTOS API to create FreeRTOS objects
* (e.g., queues). */
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
pvReturn = heap_caps_malloc(xWantedSize, portFREERTOS_HEAP_CAPS);
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
return pvReturn;
}
/*-----------------------------------------------------------*/
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
void vPortFree(void * pv)
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
{
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
heap_caps_free(pv);
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
}
/*-----------------------------------------------------------*/
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
size_t xPortGetFreeHeapSize(void)
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
{
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
return heap_caps_get_free_size(portFREERTOS_HEAP_CAPS);
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
}
/*-----------------------------------------------------------*/
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
size_t xPortGetMinimumEverFreeHeapSize(void)
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
{
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
return heap_caps_get_minimum_free_size(portFREERTOS_HEAP_CAPS);
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
}
/*-----------------------------------------------------------*/
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
bool xPortCheckValidListMem(const void * ptr)
feat(coredump): improve the probability of accessing healthy TCBs
2023-12-24 15:37:45 -05:00
{
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
#if CONFIG_IDF_TARGET_LINUX
return true;
#else /* CONFIG_IDF_TARGET_LINUX */
return esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr);
#endif /* CONFIG_IDF_TARGET_LINUX */
feat(coredump): improve the probability of accessing healthy TCBs
2023-12-24 15:37:45 -05:00
}
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
bool xPortCheckValidTCBMem(const void * ptr)
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
{
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
#if CONFIG_IDF_TARGET_LINUX
return true;
#else /* CONFIG_IDF_TARGET_LINUX */
return esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr);
#endif /* CONFIG_IDF_TARGET_LINUX */
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
}
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
bool xPortcheckValidStackMem(const void * ptr)
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
{
refactor(freertos): Updated FreeRTOS component files to astyle format This commit updates the FreeRTOS component source files (excluding upstream source files) to the astyle coding format.
2024-01-26 09:07:54 -05:00
#if CONFIG_IDF_TARGET_LINUX
return true;
#else /* CONFIG_IDF_TARGET_LINUX */
#ifdef CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY
return esp_ptr_byte_accessible(ptr);
#else
return esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr);
#endif
#endif /* CONFIG_IDF_TARGET_LINUX */
freertos(IDF): Refactor port heap functions Vanilla FreeRTOS expects applications to use one of the heap implementations provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc() and vPortFree() are defined in the heap implementation. However, ESP-IDF already provides its own heap implementation (i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were previously overriden by macro to call esp_heap functions directly. This commit refactors the FreeRTOS port's heap as such: - Added a heap_idf.c that implements all of the heap related functions required by FreeRTOS source - All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the FreeRTOS heap is the internal memory subset of the ESP-IDF heap. - Removed some old macros to reduce diff from upstream source code.
2023-03-01 06:06:10 -05:00
}
Reference in New Issue Copy Permalink