Merge branch 'refactor/esp_tee_heap_rom' into 'master'

feat(esp_tee): Use the ROM TLSF implementation for the TEE build

See merge request espressif/esp-idf!37277

Author: laukik-hase

components/esp_rom/CMakeLists.txt

@@ -133,6 +133,7 @@ endif()
 if(ESP_TEE_BUILD)
     if(target STREQUAL "esp32c6")
         rom_linker_script("spiflash")
+        rom_linker_script("heap")
     endif()
 endif()
 

components/esp_rom/include/esp_rom_tlsf.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -11,6 +11,60 @@
 extern "C" {
 #endif
 
+/* tlsf_t: a TLSF structure. Can contain 1 to N pools. */
+/* pool_t: a block of memory that TLSF can manage. */
+typedef void* tlsf_t;
+typedef void* pool_t;
+
+/* Create/destroy a memory pool. */
+tlsf_t tlsf_create(void* mem);
+tlsf_t tlsf_create_with_pool(void* mem, size_t bytes);
+pool_t tlsf_get_pool(tlsf_t tlsf);
+
+/* Add/remove memory pools. */
+pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes);
+void tlsf_remove_pool(tlsf_t tlsf, pool_t pool);
+
+/* malloc/memalign/realloc/free replacements. */
+void* tlsf_malloc(tlsf_t tlsf, size_t size);
+void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size);
+void* tlsf_memalign_offs(tlsf_t tlsf, size_t align, size_t size, size_t offset);
+void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size);
+void tlsf_free(tlsf_t tlsf, void* ptr);
+
+/* Returns internal block size, not original request size */
+size_t tlsf_block_size(void* ptr);
+
+/* Overheads/limits of internal structures. */
+size_t tlsf_size(void);
+size_t tlsf_pool_overhead(void);
+size_t tlsf_alloc_overhead(void);
+
+#if ESP_TEE_BUILD
+/* NOTE: These declarations are only needed for the TEE build, since these
+ * functions are (static inline) defined in tlsf_control_functions.h for
+ * IDF builds.
+ */
+size_t tlsf_align_size(void);
+size_t tlsf_block_size_min(void);
+size_t tlsf_block_size_max(void);
+
+/* NOTE: The consumer of this callback function (tlsf_walk_pool) is patched
+ * in IDF builds to address issues in the ROM implementation. For TEE build,
+ * the ROM declarations can be used directly, as heap integrity checking is not
+ * supported.
+ */
+typedef void (*tlsf_walker)(void* ptr, size_t size, int used, void* user);
+#else
+typedef bool (*tlsf_walker)(void* ptr, size_t size, int used, void* user);
+#endif
+
+/* Debugging. */
+void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user);
+/* Returns nonzero if any internal consistency check fails. */
+int tlsf_check(tlsf_t tlsf);
+int tlsf_check_pool(pool_t pool);
+
 /*!
  * Defines the function prototypes for multi_heap_internal_poison_fill_region
  * and multi_heap_internal_check_block_poisoning, these two function will

components/esp_rom/patches/esp_rom_tlsf.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -24,10 +24,6 @@
 #include "tlsf_block_functions.h"
 #include "tlsf_control_functions.h"
 
-/* Definition of types used in TLSF */
-typedef void* tlsf_t;
-typedef void* pool_t;
-
 static poison_check_pfunc_t s_poison_check_region = NULL;
 
 void tlsf_poison_check_pfunc_set(poison_check_pfunc_t pfunc)
@@ -43,8 +39,6 @@ typedef struct integrity_t
 	int status;
 } integrity_t;
 
-typedef bool (*tlsf_walker)(void* ptr, size_t size, int used, void* user);
-
 static bool integrity_walker(void* ptr, size_t size, int used, void* user)
 {
 	block_header_t* block = block_from_ptr(ptr);

components/esp_tee/subproject/main/CMakeLists.txt

@@ -40,10 +40,7 @@ list(APPEND include "include"
 list(APPEND srcs "common/multi_heap.c")
 
 # TLSF implementation for heap
-list(APPEND include "${heap_dir}/tlsf"
-                    "${heap_dir}/tlsf/include")
-
-list(APPEND srcs "${heap_dir}/tlsf/tlsf.c")
+list(APPEND include "${heap_dir}/tlsf")
 
 # esp_app_desc_t configuration structure for TEE
 list(APPEND srcs "common/esp_app_desc_tee.c")

components/esp_tee/subproject/main/common/multi_heap.c

@@ -1,10 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 #include <stdio.h>
-#include "tlsf.h"
+#include <stdbool.h>
+#include "esp_rom_tlsf.h"
 #include "tlsf_block_functions.h"
 #include "multi_heap.h"
 
@@ -34,36 +35,33 @@ static void assert_valid_block(const heap_t *heap, const block_header_t *block)
                       (uintptr_t)ptr);
 }
 
-int tee_heap_register(void *start_ptr, size_t size)
+esp_err_t esp_tee_heap_init(void *start_ptr, size_t size)
 {
     assert(start_ptr);
-    if (size < (sizeof(heap_t))) {
-        //Region too small to be a heap.
-        return -1;
+    if (size < (tlsf_size() + tlsf_block_size_min() + sizeof(heap_t))) {
+        // Region too small to be a heap.
+        return ESP_ERR_INVALID_SIZE;
     }
 
     heap_t *result = (heap_t *)start_ptr;
     size -= sizeof(heap_t);
 
-    /* Do not specify any maximum size for the allocations so that the default configuration is used */
-    const size_t max_bytes = 0;
-
-    result->heap_data = tlsf_create_with_pool(start_ptr + sizeof(heap_t), size, max_bytes);
+    result->heap_data = tlsf_create_with_pool(start_ptr + sizeof(heap_t), size);
     if (result->heap_data == NULL) {
-        return -1;
+        return ESP_FAIL;
     }
 
     result->lock = NULL;
-    result->free_bytes = size - tlsf_size(result->heap_data);
+    result->free_bytes = size - tlsf_size();
     result->pool_size = size;
     result->minimum_free_bytes = result->free_bytes;
 
     tee_heap = (multi_heap_handle_t)result;
 
-    return 0;
+    return ESP_OK;
 }
 
-void *tee_heap_malloc(size_t size)
+void *esp_tee_heap_malloc(size_t size)
 {
     if (tee_heap == NULL || size == 0) {
         return NULL;
@@ -81,17 +79,17 @@ void *tee_heap_malloc(size_t size)
     return result;
 }
 
-void *tee_heap_calloc(size_t n, size_t size)
+void *esp_tee_heap_calloc(size_t n, size_t size)
 {
     size_t reg_size = n * size;
-    void *ptr = tee_heap_malloc(reg_size);
+    void *ptr = esp_tee_heap_malloc(reg_size);
     if (ptr != NULL) {
         memset(ptr, 0x00, reg_size);
     }
     return ptr;
 }
 
-void *tee_heap_aligned_alloc(size_t size, size_t alignment)
+void *esp_tee_heap_aligned_alloc(size_t size, size_t alignment)
 {
     if (tee_heap == NULL || size == 0) {
         return NULL;
@@ -114,7 +112,7 @@ void *tee_heap_aligned_alloc(size_t size, size_t alignment)
     return result;
 }
 
-void tee_heap_free(void *p)
+void esp_tee_heap_free(void *p)
 {
     if (tee_heap == NULL || p == NULL) {
         return;
@@ -129,67 +127,64 @@ void tee_heap_free(void *p)
 
 void *malloc(size_t size)
 {
-    return tee_heap_malloc(size);
+    return esp_tee_heap_malloc(size);
 }
 
 void *calloc(size_t n, size_t size)
 {
-    return tee_heap_calloc(n, size);
+    return esp_tee_heap_calloc(n, size);
 }
 
 void free(void *ptr)
 {
-    tee_heap_free(ptr);
+    esp_tee_heap_free(ptr);
 }
 
-void tee_heap_dump_free_size(void)
+size_t esp_tee_heap_get_free_size(void)
 {
-    if (tee_heap == NULL) {
-        return;
-    }
-    printf("Free: %uB | Minimum free: %uB\n", tee_heap->free_bytes, tee_heap->minimum_free_bytes);
+    return tee_heap->free_bytes;
+}
+
+size_t esp_tee_heap_get_min_free_size(void)
+{
+    return tee_heap->minimum_free_bytes;
 }
 
-static bool tee_heap_dump_tlsf(void* ptr, size_t size, int used, void* user)
+static void heap_dump_tlsf(void* ptr, size_t size, int used, void* user)
 {
     (void)user;
     printf("Block %p data, size: %d bytes, Free: %s\n",
            (void *)ptr,
            size,
            used ? "No" : "Yes");
-    return true;
 }
 
-void tee_heap_dump_info(void)
+void esp_tee_heap_dump_info(void)
 {
-    if (tee_heap == NULL) {
-        return;
-    }
-    printf("Showing data for TEE heap: %p\n", (void *)tee_heap);
-    tee_heap_dump_free_size();
-    tlsf_walk_pool(tlsf_get_pool(tee_heap->heap_data), tee_heap_dump_tlsf, NULL);
+    printf("Showing data for TEE heap: %p (%uB)\n", (void *)tee_heap, tee_heap->pool_size);
+    tlsf_walk_pool(tlsf_get_pool(tee_heap->heap_data), heap_dump_tlsf, NULL);
 }
 
 /* Definitions for functions from the heap component, used in files shared with ESP-IDF */
 
 void *heap_caps_malloc(size_t alignment, size_t size, uint32_t caps)
 {
     (void) caps;
-    return tee_heap_malloc(size);
+    return esp_tee_heap_malloc(size);
 }
 
 void *heap_caps_aligned_alloc(size_t alignment, size_t size, uint32_t caps)
 {
     (void) caps;
-    return tee_heap_aligned_alloc(size, alignment);
+    return esp_tee_heap_aligned_alloc(size, alignment);
 }
 
 void *heap_caps_aligned_calloc(size_t alignment, size_t n, size_t size, uint32_t caps)
 {
     (void) caps;
     uint32_t reg_size = n * size;
 
-    void *ptr = tee_heap_aligned_alloc(reg_size, alignment);
+    void *ptr = esp_tee_heap_aligned_alloc(reg_size, alignment);
     if (ptr != NULL) {
         memset(ptr, 0x00, reg_size);
     }

components/esp_tee/subproject/main/core/esp_tee_init.c

@@ -132,7 +132,7 @@ void __attribute__((noreturn)) esp_tee_init(uint32_t ree_entry_addr, uint32_t re
     tee_init_app_config();
 
     /* TEE Secure World heap initialization. */
-    assert(tee_heap_register(((void *)&_tee_heap_start), TEE_HEAP_SIZE) == 0);
+    assert(esp_tee_heap_init(((void *)&_tee_heap_start), TEE_HEAP_SIZE) == ESP_OK);
 
     /* SoC specific secure initialization. */
     esp_tee_soc_secure_sys_init();