espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-07-31 19:24:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor(espcoredump): replace uart and flash callbacks with aliases

Browse Source
This commit is contained in:
Erhan Kurubas
2024-02-23 22:53:14 +01:00
committed by BOT
parent 25e69d8f01
commit 210d06e7e4
9 changed files with 109 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
components/espcoredump/include_core_dump/core_dump_binary.h
View File

@@ -1,22 +0,0 @@
/*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ESP_CORE_DUMP_BINARY_H_
#define ESP_CORE_DUMP_BINARY_H_
#include "esp_core_dump_types.h"
/**
* @brief Initiate the binary core dump generation.
*
* @param info Exception frame info generated when the panic occured.
* @param write_cfg Structure containing the callbacks that will be called to
* write the generated core dump file.
*
* @return ESP_OK on success, otherwise \see esp_err_t.
*/
esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg);
#endif

22
components/espcoredump/include_core_dump/core_dump_elf.h
View File

@@ -1,22 +0,0 @@
/*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ESP_CORE_DUMP_ELF_H_
#define ESP_CORE_DUMP_ELF_H_
#include "esp_core_dump_types.h"
/**
* @brief Initiate the ELF core dump generation.
*
* @param info Exception frame info generated when the panic occured.
* @param write_cfg Structre containing the callbacks that will be called to
* write the generated core dump data.
*
* @return ESP_OK on success, otherwise \see esp_err_t.
*/
esp_err_t esp_core_dump_write_elf(core_dump_write_config_t *write_cfg);
#endif

22
components/espcoredump/include_core_dump/esp_core_dump_common.h
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -111,6 +111,26 @@ bool esp_core_dump_in_isr_context(void);
uint32_t esp_core_dump_get_user_ram_size(void); uint32_t esp_core_dump_get_user_ram_size(void);
/**
* @brief Function called to prepare flash/uart for the data storage
*/
esp_err_t esp_core_dump_write_prepare(core_dump_write_data_t *wr_data, uint32_t *data_len);
/**
* @brief Function called at the beginning of data writing
*/
esp_err_t esp_core_dump_write_start(core_dump_write_data_t *wr_data);
/**
* @brief Function called to write data chunk
*/
esp_err_t esp_core_dump_write_data(core_dump_write_data_t *wr_data, void *data, uint32_t data_len);
/**
* @brief Function called once all data have been written
*/
esp_err_t esp_core_dump_write_end(core_dump_write_data_t *wr_data);
/** /**
* @brief Get TCB length, in bytes. * @brief Get TCB length, in bytes.
* *

34
components/espcoredump/include_core_dump/esp_core_dump_types.h
View File

@@ -137,38 +137,6 @@ typedef struct _core_dump_write_data_t
checksum_ctx_t checksum_ctx; /*!< Checksum context */ checksum_ctx_t checksum_ctx; /*!< Checksum context */
} core_dump_write_data_t; } core_dump_write_data_t;
/**
* @brief Types below define the signatures of the callbacks that are used
* to output a core dump. The destination of the dump is implementation
* dependant.
*/
typedef esp_err_t (*esp_core_dump_write_prepare_t)(core_dump_write_data_t* priv, uint32_t *data_len);
typedef esp_err_t (*esp_core_dump_write_start_t)(core_dump_write_data_t* priv);
typedef esp_err_t (*esp_core_dump_write_end_t)(core_dump_write_data_t* priv);
typedef esp_err_t (*esp_core_dump_flash_write_data_t)(core_dump_write_data_t* priv,
void * data,
uint32_t data_len);
/**
* @brief Core dump emitter control structure.
* This structure contains the functions that are called in order to write
* the core dump to the destination (UART or flash).
* The function are called in this order:
* - prepare
* - start
* - write （called once or more）
* - end
*/
typedef struct _core_dump_write_config_t
{
esp_core_dump_write_prepare_t prepare; /*!< Function called for sanity checks */
esp_core_dump_write_start_t start; /*!< Function called at the beginning of data writing */
esp_core_dump_flash_write_data_t write; /*!< Function called to write data chunk */
esp_core_dump_write_end_t end; /*!< Function called once all data have been written */
core_dump_write_data_t* priv; /*!< Private context to pass to every function of this structure */
} core_dump_write_config_t;
/** /**
* @brief Core dump data header * @brief Core dump data header
* This header predecesses the actual core dump data (ELF or binary). */ * This header predecesses the actual core dump data (ELF or binary). */
@@ -215,7 +183,7 @@ void esp_core_dump_flash_init(void);
/** /**
* @brief Common core dump write function * @brief Common core dump write function
*/ */
void esp_core_dump_write(panic_info_t *info, core_dump_write_config_t *write_cfg); void esp_core_dump_write(panic_info_t *info);
#ifdef __cplusplus #ifdef __cplusplus
} }

76
components/espcoredump/src/core_dump_binary.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -7,7 +7,6 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include "sdkconfig.h" #include "sdkconfig.h"
#include "core_dump_binary.h"
#include "esp_core_dump_port.h" #include "esp_core_dump_port.h"
#include "esp_core_dump_common.h" #include "esp_core_dump_common.h"
@@ -15,9 +14,7 @@
const static char TAG[] __attribute__((unused)) = "esp_core_dump_binary"; const static char TAG[] __attribute__((unused)) = "esp_core_dump_binary";
static esp_err_t esp_core_dump_save_task(core_dump_write_data_t *write_data, core_dump_task_header_t *task)
static esp_err_t esp_core_dump_save_task(core_dump_write_config_t *write_cfg,
core_dump_task_header_t *task)
{ {
esp_err_t err = ESP_FAIL; esp_err_t err = ESP_FAIL;
uint32_t stk_vaddr = 0; uint32_t stk_vaddr = 0;
@@ -27,19 +24,19 @@ static esp_err_t esp_core_dump_save_task(core_dump_write_config_t *write_cfg,
stk_len = esp_core_dump_get_memory_len(stk_vaddr, stk_vaddr+stk_len); stk_len = esp_core_dump_get_memory_len(stk_vaddr, stk_vaddr+stk_len);
// Save memory segment header // Save memory segment header
err = write_cfg->write(write_cfg->priv, (void*)task, sizeof(core_dump_task_header_t)); err = esp_core_dump_write_data(write_data, task, sizeof(core_dump_task_header_t));
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to write task header, error=%d!", err); ESP_COREDUMP_LOGE("Failed to write task header, error=%d!", err);
return err; return err;
} }
// Save TCB block // Save TCB block
err = write_cfg->write(write_cfg->priv, task->tcb_addr, esp_core_dump_get_tcb_len()); err = esp_core_dump_write_data(write_data, task->tcb_addr, esp_core_dump_get_tcb_len());
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to write TCB, error=%d!", err); ESP_COREDUMP_LOGE("Failed to write TCB, error=%d!", err);
return err; return err;
} }
// Save task stack // Save task stack
err = write_cfg->write(write_cfg->priv, (void*)stk_paddr, stk_len); err = esp_core_dump_write_data(write_data, (void *)stk_paddr, stk_len);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to write stack for task (TCB:%x), stack_start=%x, error=%d!", ESP_COREDUMP_LOGE("Failed to write stack for task (TCB:%x), stack_start=%x, error=%d!",
task->tcb_addr, task->tcb_addr,
@@ -48,12 +45,12 @@ static esp_err_t esp_core_dump_save_task(core_dump_write_config_t *write_cfg,
return err; return err;
} }
ESP_COREDUMP_LOG_PROCESS("Task (TCB:%x) dump is saved.", ESP_COREDUMP_LOG_PROCESS("Task (TCB:%x) dump is saved.", task->tcb_addr);
task->tcb_addr);
return ESP_OK; return ESP_OK;
} }
static esp_err_t esp_core_dump_save_mem_segment(core_dump_write_config_t* write_cfg, static esp_err_t esp_core_dump_save_mem_segment(core_dump_write_data_t* write_data,
core_dump_mem_seg_header_t* seg) core_dump_mem_seg_header_t* seg)
{ {
esp_err_t err = ESP_FAIL; esp_err_t err = ESP_FAIL;
@@ -63,14 +60,14 @@ static esp_err_t esp_core_dump_save_mem_segment(core_dump_write_config_t* write_
seg->start, seg->size); seg->start, seg->size);
return ESP_FAIL; return ESP_FAIL;
} }
// Save TCB address, stack base and stack top addr // Save TCB address, stack base and stack top addrq
err = write_cfg->write(write_cfg->priv, (void*)seg, sizeof(core_dump_mem_seg_header_t)); err = esp_core_dump_write_data(write_data, seg, sizeof(core_dump_mem_seg_header_t));
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to write memory segment header, error=%d!", err); ESP_COREDUMP_LOGE("Failed to write memory segment header, error=%d!", err);
return err; return err;
} }
// Save memory contents // Save memory contents
err = write_cfg->write(write_cfg->priv, (void*)seg->start, seg->size); err = esp_core_dump_write_data(write_data, (void *)seg->start, seg->size);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to write memory segment, (%x, %lu), error=%d!", ESP_COREDUMP_LOGE("Failed to write memory segment, (%x, %lu), error=%d!",
seg->start, seg->size, err); seg->start, seg->size, err);
@@ -81,12 +78,13 @@ static esp_err_t esp_core_dump_save_mem_segment(core_dump_write_config_t* write_
return ESP_OK; return ESP_OK;
} }
esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg) esp_err_t esp_core_dump_write_binary(void)
{ {
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
uint32_t tcb_sz = esp_core_dump_get_tcb_len(); uint32_t tcb_sz = esp_core_dump_get_tcb_len();
uint32_t data_len = 0; uint32_t data_len = 0;
uint32_t bad_tasks_num = 0; uint32_t bad_tasks_num = 0;
core_dump_write_data_t write_data = { 0 };
core_dump_header_t hdr = { 0 }; core_dump_header_t hdr = { 0 };
core_dump_task_header_t task_hdr = { 0 }; core_dump_task_header_t task_hdr = { 0 };
core_dump_mem_seg_header_t mem_seg = { 0 }; core_dump_mem_seg_header_t mem_seg = { 0 };
@@ -154,28 +152,24 @@ esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg)
ESP_COREDUMP_LOG_PROCESS("Core dump length=%lu, tasks processed: %d, broken tasks: %d", ESP_COREDUMP_LOG_PROCESS("Core dump length=%lu, tasks processed: %d, broken tasks: %d",
data_len, hdr.tasks_num, bad_tasks_num); data_len, hdr.tasks_num, bad_tasks_num);
// Prepare write // Prepare write
if (write_cfg->prepare) { err = esp_core_dump_write_prepare(&write_data, &data_len);
err = write_cfg->prepare(write_cfg->priv, &data_len); if (err != ESP_OK) {
if (err != ESP_OK) { ESP_COREDUMP_LOGE("Failed to prepare core dump, error=%d!", err);
ESP_COREDUMP_LOGE("Failed to prepare core dump, error=%d!", err); return err;
return err;
}
} }
// Write start // Write start
if (write_cfg->start) { err = esp_core_dump_write_start(&write_data);
err = write_cfg->start(write_cfg->priv); if (err != ESP_OK) {
if (err != ESP_OK) { ESP_COREDUMP_LOGE("Failed to start core dump, error=%d!", err);
ESP_COREDUMP_LOGE("Failed to start core dump, error=%d!", err); return err;
return err;
}
} }
// Write header // Write header
hdr.data_len = data_len; hdr.data_len = data_len;
hdr.version = COREDUMP_VERSION_BIN_CURRENT; hdr.version = COREDUMP_VERSION_BIN_CURRENT;
hdr.tcb_sz = tcb_sz; hdr.tcb_sz = tcb_sz;
err = write_cfg->write(write_cfg->priv, &hdr, sizeof(core_dump_header_t)); err = esp_core_dump_write_data(&write_data, &hdr, sizeof(core_dump_header_t));
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to write core dump header error=%d!", err); ESP_COREDUMP_LOGE("Failed to write core dump header error=%d!", err);
return err; return err;
@@ -186,7 +180,7 @@ esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg)
// Write first crashed task data first (not always first task in the snapshot) // Write first crashed task data first (not always first task in the snapshot)
ESP_COREDUMP_LOGD("Save first crashed task %x", cur_task); ESP_COREDUMP_LOGD("Save first crashed task %x", cur_task);
if (esp_core_dump_get_task_snapshot(cur_task, &task_hdr, NULL)) { if (esp_core_dump_get_task_snapshot(cur_task, &task_hdr, NULL)) {
err = esp_core_dump_save_task(write_cfg, &task_hdr); err = esp_core_dump_save_task(&write_data, &task_hdr);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to save first crashed task %x, error=%d!", ESP_COREDUMP_LOGE("Failed to save first crashed task %x, error=%d!",
task_hdr.tcb_addr, err); task_hdr.tcb_addr, err);
@@ -202,8 +196,9 @@ esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg)
if (task == cur_task) { if (task == cur_task) {
continue; continue;
} }
ESP_COREDUMP_LOGD("Save task %x (TCB:%x, stack:%x..%x)", task, task_hdr.tcb_addr, task_hdr.stack_start, task_hdr.stack_end); ESP_COREDUMP_LOGD("Save task %x (TCB:%x, stack:%x..%x)",
err = esp_core_dump_save_task(write_cfg, &task_hdr); task, task_hdr.tcb_addr, task_hdr.stack_start, task_hdr.stack_end);
err = esp_core_dump_save_task(&write_data, &task_hdr);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to save core dump task %x, error=%d!", ESP_COREDUMP_LOGE("Failed to save core dump task %x, error=%d!",
task_hdr.tcb_addr, err); task_hdr.tcb_addr, err);
@@ -220,8 +215,8 @@ esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg)
continue; continue;
if (mem_seg.size > 0) { if (mem_seg.size > 0) {
ESP_COREDUMP_LOG_PROCESS("Save interrupted task stack %lu bytes @ %x", ESP_COREDUMP_LOG_PROCESS("Save interrupted task stack %lu bytes @ %x",
mem_seg.size, mem_seg.start); mem_seg.size, mem_seg.start);
err = esp_core_dump_save_mem_segment(write_cfg, &mem_seg); err = esp_core_dump_save_mem_segment(&write_data, &mem_seg);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to save interrupted task stack, error=%d!", err); ESP_COREDUMP_LOGE("Failed to save interrupted task stack, error=%d!", err);
return err; return err;
@@ -244,8 +239,8 @@ esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg)
mem_seg.start = start; mem_seg.start = start;
mem_seg.size = esp_core_dump_get_memory_len(start, start + data_sz);; mem_seg.size = esp_core_dump_get_memory_len(start, start + data_sz);;
ESP_COREDUMP_LOG_PROCESS("Save user memory region %lu bytes @ %x", ESP_COREDUMP_LOG_PROCESS("Save user memory region %lu bytes @ %x",
mem_seg.size, mem_seg.start); mem_seg.size, mem_seg.start);
err = esp_core_dump_save_mem_segment(write_cfg, &mem_seg); err = esp_core_dump_save_mem_segment(&write_data, &mem_seg);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to save user memory region, error=%d!", err); ESP_COREDUMP_LOGE("Failed to save user memory region, error=%d!", err);
return err; return err;
@@ -255,13 +250,12 @@ esp_err_t esp_core_dump_write_binary(core_dump_write_config_t *write_cfg)
} }
// Write end // Write end
if (write_cfg->end) { err = esp_core_dump_write_end(&write_data);
err = write_cfg->end(write_cfg->priv); if (err != ESP_OK) {
if (err != ESP_OK) { ESP_COREDUMP_LOGE("Failed to end core dump error=%d!", err);
ESP_COREDUMP_LOGE("Failed to end core dump error=%d!", err); return err;
return err;
}
} }
if (bad_tasks_num) { if (bad_tasks_num) {
ESP_COREDUMP_LOGE("Found %d broken tasks!", bad_tasks_num); ESP_COREDUMP_LOGE("Found %d broken tasks!", bad_tasks_num);
} }

12
components/espcoredump/src/core_dump_common.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -12,8 +12,6 @@
#include "esp_rom_sys.h" #include "esp_rom_sys.h"
#include "esp_core_dump_port.h" #include "esp_core_dump_port.h"
#include "esp_core_dump_common.h" #include "esp_core_dump_common.h"
#include "core_dump_elf.h"
#include "core_dump_binary.h"
const static char TAG[] __attribute__((unused)) = "esp_core_dump_common"; const static char TAG[] __attribute__((unused)) = "esp_core_dump_common";
@@ -145,7 +143,7 @@ FORCE_INLINE_ATTR void esp_core_dump_report_stack_usage(void)
static void* s_exc_frame = NULL; static void* s_exc_frame = NULL;
inline void esp_core_dump_write(panic_info_t *info, core_dump_write_config_t *write_cfg) inline void esp_core_dump_write(panic_info_t *info)
{ {
#ifndef CONFIG_ESP_COREDUMP_ENABLE_TO_NONE #ifndef CONFIG_ESP_COREDUMP_ENABLE_TO_NONE
esp_err_t err = ESP_ERR_NOT_SUPPORTED; esp_err_t err = ESP_ERR_NOT_SUPPORTED;
@@ -156,9 +154,11 @@ inline void esp_core_dump_write(panic_info_t *info, core_dump_write_config_t *wr
esp_core_dump_setup_stack(); esp_core_dump_setup_stack();
esp_core_dump_port_init(info, isr_context); esp_core_dump_port_init(info, isr_context);
#if CONFIG_ESP_COREDUMP_DATA_FORMAT_BIN #if CONFIG_ESP_COREDUMP_DATA_FORMAT_BIN
err = esp_core_dump_write_binary(write_cfg); esp_err_t esp_core_dump_write_binary(void);
err = esp_core_dump_write_binary();
#elif CONFIG_ESP_COREDUMP_DATA_FORMAT_ELF #elif CONFIG_ESP_COREDUMP_DATA_FORMAT_ELF
err = esp_core_dump_write_elf(write_cfg); esp_err_t esp_core_dump_write_elf(void);
err = esp_core_dump_write_elf();
#endif #endif
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Core dump write binary failed with error=%d", err); ESP_COREDUMP_LOGE("Core dump write binary failed with error=%d", err);

59
components/espcoredump/src/core_dump_elf.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -9,7 +9,6 @@
#include "esp_flash_encrypt.h" #include "esp_flash_encrypt.h"
#include "sdkconfig.h" #include "sdkconfig.h"
#include "core_dump_checksum.h" #include "core_dump_checksum.h"
#include "core_dump_elf.h"
#include "esp_core_dump_port.h" #include "esp_core_dump_port.h"
#include "esp_core_dump_port_impl.h" #include "esp_core_dump_port_impl.h"
#include "esp_core_dump_common.h" #include "esp_core_dump_common.h"
@@ -80,7 +79,7 @@ typedef struct _core_dump_elf_t
uint16_t elf_stage; uint16_t elf_stage;
uint32_t elf_next_data_offset; uint32_t elf_next_data_offset;
uint16_t segs_count; uint16_t segs_count;
core_dump_write_config_t * write_cfg; core_dump_write_data_t write_data;
} core_dump_elf_t; } core_dump_elf_t;
// Represents lightweight implementation to save core dump data into ELF formatted binary // Represents lightweight implementation to save core dump data into ELF formatted binary
@@ -126,7 +125,7 @@ static int elf_write_file_header(core_dump_elf_t *self, uint32_t seg_count)
elf_hdr.e_shnum = 0; // initial section counter is 0 elf_hdr.e_shnum = 0; // initial section counter is 0
elf_hdr.e_shstrndx = SHN_UNDEF; // do not use string table elf_hdr.e_shstrndx = SHN_UNDEF; // do not use string table
// write built elf header into elf image // write built elf header into elf image
esp_err_t err = self->write_cfg->write(self->write_cfg->priv, (void*)&elf_hdr, sizeof(elf_hdr)); esp_err_t err = esp_core_dump_write_data(&self->write_data, &elf_hdr, sizeof(elf_hdr));
ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL, ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL,
"Write ELF header failure (%d)", err); "Write ELF header failure (%d)", err);
ESP_COREDUMP_LOG_PROCESS("Add file header %u bytes", sizeof(elf_hdr)); ESP_COREDUMP_LOG_PROCESS("Add file header %u bytes", sizeof(elf_hdr));
@@ -142,7 +141,7 @@ static int elf_write_segment_header(core_dump_elf_t *self, elf_phdr* phdr)
phdr->p_offset = self->elf_next_data_offset; phdr->p_offset = self->elf_next_data_offset;
// set segment data information and write it into image // set segment data information and write it into image
esp_err_t err = self->write_cfg->write(self->write_cfg->priv, (void*)phdr, sizeof(elf_phdr)); esp_err_t err = esp_core_dump_write_data(&self->write_data, phdr, sizeof(elf_phdr));
ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL, ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL,
"Write ELF segment header failure (%d)", err); "Write ELF segment header failure (%d)", err);
ESP_COREDUMP_LOG_PROCESS("Add segment header %u bytes: type %d, sz %u, off = 0x%x", ESP_COREDUMP_LOG_PROCESS("Add segment header %u bytes: type %d, sz %u, off = 0x%x",
@@ -185,7 +184,7 @@ static int elf_add_segment(core_dump_elf_t *self,
(uint32_t)data_len, self->elf_next_data_offset); (uint32_t)data_len, self->elf_next_data_offset);
// write segment data only when write function is set and phdr = NULL // write segment data only when write function is set and phdr = NULL
// write data into segment // write data into segment
err = self->write_cfg->write(self->write_cfg->priv, data, (uint32_t)data_len); err = esp_core_dump_write_data(&self->write_data, data, (uint32_t)data_len);
ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL, ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL,
"Write ELF segment data failure (%d)", err); "Write ELF segment data failure (%d)", err);
self->elf_next_data_offset += data_len; self->elf_next_data_offset += data_len;
@@ -222,15 +221,15 @@ static int elf_write_note(core_dump_elf_t *self,
note_hdr.n_descsz = data_sz; note_hdr.n_descsz = data_sz;
note_hdr.n_type = type; note_hdr.n_type = type;
// write note header // write note header
err = self->write_cfg->write(self->write_cfg->priv, (void*)&note_hdr, sizeof(note_hdr)); err = esp_core_dump_write_data(&self->write_data, (void*)&note_hdr, sizeof(note_hdr));
ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL, ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL,
"Write ELF note header failure (%d)", err); "Write ELF note header failure (%d)", err);
// write note name // write note name
err = self->write_cfg->write(self->write_cfg->priv, (void*)name_buffer, name_len); err = esp_core_dump_write_data(&self->write_data, (void*)name_buffer, name_len);
ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL, ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL,
"Write ELF note name failure (%d)", err); "Write ELF note name failure (%d)", err);
// write note data // write note data
err = self->write_cfg->write(self->write_cfg->priv, (void*)data, data_len); err = esp_core_dump_write_data(&self->write_data, (void*)data, data_len);
ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL, ELF_CHECK_ERR((err == ESP_OK), ELF_PROC_ERR_WRITE_FAIL,
"Write ELF note data failure (%d)", err); "Write ELF note data failure (%d)", err);
ESP_COREDUMP_LOG_PROCESS("Add note size=%d, start_off=0x%x", ESP_COREDUMP_LOG_PROCESS("Add note size=%d, start_off=0x%x",
@@ -572,18 +571,14 @@ static int esp_core_dump_do_write_elf_pass(core_dump_elf_t *self)
return tot_len; return tot_len;
} }
esp_err_t esp_core_dump_write_elf(core_dump_write_config_t *write_cfg) esp_err_t esp_core_dump_write_elf(void)
{ {
static core_dump_elf_t self = { 0 }; core_dump_elf_t self = { 0 };
static core_dump_header_t dump_hdr = { 0 }; core_dump_header_t dump_hdr = { 0 };
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
int tot_len = sizeof(dump_hdr); int tot_len = sizeof(dump_hdr);
int write_len = sizeof(dump_hdr); int write_len = sizeof(dump_hdr);
ELF_CHECK_ERR((write_cfg), ESP_ERR_INVALID_ARG, "Invalid input data.");
self.write_cfg = write_cfg;
// On first pass (do not write actual data), but calculate data length needed to allocate memory // On first pass (do not write actual data), but calculate data length needed to allocate memory
self.elf_stage = ELF_STAGE_CALC_SPACE; self.elf_stage = ELF_STAGE_CALC_SPACE;
ESP_COREDUMP_LOG_PROCESS("================= Calc data size ==============="); ESP_COREDUMP_LOG_PROCESS("================= Calc data size ===============");
@@ -594,21 +589,17 @@ esp_err_t esp_core_dump_write_elf(core_dump_write_config_t *write_cfg)
ESP_COREDUMP_LOG_PROCESS("============== Data size = %d bytes ============", tot_len); ESP_COREDUMP_LOG_PROCESS("============== Data size = %d bytes ============", tot_len);
// Prepare write elf // Prepare write elf
if (write_cfg->prepare) { err = esp_core_dump_write_prepare(&self.write_data, (uint32_t*)&tot_len);
err = write_cfg->prepare(write_cfg->priv, (uint32_t*)&tot_len); if (err != ESP_OK) {
if (err != ESP_OK) { ESP_COREDUMP_LOGE("Failed to prepare core dump storage (%d)!", err);
ESP_COREDUMP_LOGE("Failed to prepare core dump storage (%d)!", err); return err;
return err;
}
} }
// Write start // Write start
if (write_cfg->start) { err = esp_core_dump_write_start(&self.write_data);
err = write_cfg->start(write_cfg->priv); if (err != ESP_OK) {
if (err != ESP_OK) { ESP_COREDUMP_LOGE("Failed to start core dump (%d)!", err);
ESP_COREDUMP_LOGE("Failed to start core dump (%d)!", err); return err;
return err;
}
} }
// Write core dump header // Write core dump header
@@ -617,7 +608,7 @@ esp_err_t esp_core_dump_write_elf(core_dump_write_config_t *write_cfg)
dump_hdr.tasks_num = 0; // unused in ELF format dump_hdr.tasks_num = 0; // unused in ELF format
dump_hdr.tcb_sz = 0; // unused in ELF format dump_hdr.tcb_sz = 0; // unused in ELF format
dump_hdr.mem_segs_num = 0; // unused in ELF format dump_hdr.mem_segs_num = 0; // unused in ELF format
err = write_cfg->write(write_cfg->priv, err = esp_core_dump_write_data(&self.write_data,
(void*)&dump_hdr, (void*)&dump_hdr,
sizeof(core_dump_header_t)); sizeof(core_dump_header_t));
if (err != ESP_OK) { if (err != ESP_OK) {
@@ -642,13 +633,11 @@ esp_err_t esp_core_dump_write_elf(core_dump_write_config_t *write_cfg)
ESP_COREDUMP_LOG_PROCESS("=========== Data written size = %d bytes ==========", write_len); ESP_COREDUMP_LOG_PROCESS("=========== Data written size = %d bytes ==========", write_len);
// Write end, update checksum // Write end, update checksum
if (write_cfg->end) { err = esp_core_dump_write_end(&self.write_data);
err = write_cfg->end(write_cfg->priv); if (err != ESP_OK) {
if (err != ESP_OK) { ESP_COREDUMP_LOGE("Failed to end core dump (%d)!", err);
ESP_COREDUMP_LOGE("Failed to end core dump (%d)!", err);
return err;
}
} }
return err; return err;
} }

29
components/espcoredump/src/core_dump_flash.c
View File

@@ -39,6 +39,11 @@ typedef struct _core_dump_flash_config_t {
/* Core dump flash data. */ /* Core dump flash data. */
static core_dump_flash_config_t s_core_flash_config; static core_dump_flash_config_t s_core_flash_config;
esp_err_t esp_core_dump_write_prepare(core_dump_write_data_t *wr_data, uint32_t *data_len) __attribute__((alias("esp_core_dump_flash_write_prepare")));
esp_err_t esp_core_dump_write_start(core_dump_write_data_t *wr_data) __attribute__((alias("esp_core_dump_flash_write_start")));
esp_err_t esp_core_dump_write_end(core_dump_write_data_t *wr_data) __attribute__((alias("esp_core_dump_flash_write_end")));
esp_err_t esp_core_dump_write_data(core_dump_write_data_t *wr_data, void *data, uint32_t data_len) __attribute__((alias("esp_core_dump_flash_write_data")));
#define ESP_COREDUMP_FLASH_WRITE(_off_, _data_, _len_) esp_flash_write(esp_flash_default_chip, _data_, _off_, _len_) #define ESP_COREDUMP_FLASH_WRITE(_off_, _data_, _len_) esp_flash_write(esp_flash_default_chip, _data_, _off_, _len_)
#define ESP_COREDUMP_FLASH_WRITE_ENCRYPTED(_off_, _data_, _len_) esp_flash_write_encrypted(esp_flash_default_chip, _off_, _data_, _len_) #define ESP_COREDUMP_FLASH_WRITE_ENCRYPTED(_off_, _data_, _len_) esp_flash_write_encrypted(esp_flash_default_chip, _off_, _data_, _len_)
#define ESP_COREDUMP_FLASH_ERASE(_off_, _len_) esp_flash_erase_region(esp_flash_default_chip, _off_, _len_) #define ESP_COREDUMP_FLASH_ERASE(_off_, _len_) esp_flash_erase_region(esp_flash_default_chip, _off_, _len_)
@@ -86,9 +91,8 @@ void esp_core_dump_flash_init(void)
} }
} }
static esp_err_t esp_core_dump_flash_write_data(core_dump_write_data_t* priv, uint8_t* data, uint32_t data_size) static esp_err_t esp_core_dump_flash_write_data(core_dump_write_data_t* wr_data, uint8_t* data, uint32_t data_size)
{ {
core_dump_write_data_t *wr_data = (core_dump_write_data_t *)priv;
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
uint32_t written = 0; uint32_t written = 0;
uint32_t wr_sz = 0; uint32_t wr_sz = 0;
@@ -178,9 +182,8 @@ static esp_err_t esp_core_dump_flash_write_data(core_dump_write_data_t* priv, ui
return ESP_OK; return ESP_OK;
} }
static esp_err_t esp_core_dump_flash_write_prepare(core_dump_write_data_t *priv, uint32_t *data_len) static esp_err_t esp_core_dump_flash_write_prepare(core_dump_write_data_t *wr_data, uint32_t *data_len)
{ {
core_dump_write_data_t *wr_data = (core_dump_write_data_t *)priv;
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
uint32_t sec_num = 0; uint32_t sec_num = 0;
uint32_t cs_len = 0; uint32_t cs_len = 0;
@@ -230,19 +233,17 @@ static esp_err_t esp_core_dump_flash_write_prepare(core_dump_write_data_t *priv,
return err; return err;
} }
static esp_err_t esp_core_dump_flash_write_start(core_dump_write_data_t* priv) static esp_err_t esp_core_dump_flash_write_start(core_dump_write_data_t *wr_data)
{ {
core_dump_write_data_t *wr_data = (core_dump_write_data_t *)priv;
esp_core_dump_checksum_init(&wr_data->checksum_ctx); esp_core_dump_checksum_init(&wr_data->checksum_ctx);
return ESP_OK; return ESP_OK;
} }
static esp_err_t esp_core_dump_flash_write_end(core_dump_write_data_t* priv) static esp_err_t esp_core_dump_flash_write_end(core_dump_write_data_t *wr_data)
{ {
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
core_dump_checksum_bytes checksum = NULL; core_dump_checksum_bytes checksum = NULL;
uint32_t cs_len = 0; uint32_t cs_len = 0;
core_dump_write_data_t *wr_data = (core_dump_write_data_t *)priv;
/* Get the size, in bytes of the checksum. */ /* Get the size, in bytes of the checksum. */
cs_len = esp_core_dump_checksum_size(); cs_len = esp_core_dump_checksum_size();
@@ -299,9 +300,6 @@ static esp_err_t esp_core_dump_flash_write_end(core_dump_write_data_t* priv)
void esp_core_dump_to_flash(panic_info_t *info) void esp_core_dump_to_flash(panic_info_t *info)
{ {
core_dump_write_config_t wr_cfg = { 0 };
core_dump_write_data_t wr_data = { 0 };
/* Check core dump partition configuration. */ /* Check core dump partition configuration. */
core_dump_crc_t crc = esp_core_dump_calc_flash_config_crc(); core_dump_crc_t crc = esp_core_dump_calc_flash_config_crc();
if (s_core_flash_config.partition_config_crc != crc) { if (s_core_flash_config.partition_config_crc != crc) {
@@ -319,15 +317,8 @@ void esp_core_dump_to_flash(panic_info_t *info)
spi_flash_guard_set(&g_flash_guard_no_os_ops); spi_flash_guard_set(&g_flash_guard_no_os_ops);
esp_flash_app_disable_protect(true); esp_flash_app_disable_protect(true);
/* Register the callbacks that will be called later by the generic part. */
wr_cfg.prepare = esp_core_dump_flash_write_prepare;
wr_cfg.start = esp_core_dump_flash_write_start;
wr_cfg.end = esp_core_dump_flash_write_end;
wr_cfg.write = (esp_core_dump_flash_write_data_t) esp_core_dump_flash_write_data;
wr_cfg.priv = &wr_data;
ESP_COREDUMP_LOGI("Save core dump to flash..."); ESP_COREDUMP_LOGI("Save core dump to flash...");
esp_core_dump_write(info, &wr_cfg); esp_core_dump_write(info);
ESP_COREDUMP_LOGI("Core dump has been saved to flash."); ESP_COREDUMP_LOGI("Core dump has been saved to flash.");
} }

30
components/espcoredump/src/core_dump_uart.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -17,6 +17,11 @@ const static char TAG[] __attribute__((unused)) = "esp_core_dump_uart";
#if CONFIG_ESP_COREDUMP_ENABLE_TO_UART #if CONFIG_ESP_COREDUMP_ENABLE_TO_UART
esp_err_t esp_core_dump_write_prepare(core_dump_write_data_t *wr_data, uint32_t *data_len) __attribute__((alias("esp_core_dump_uart_write_prepare")));
esp_err_t esp_core_dump_write_start(core_dump_write_data_t *wr_data) __attribute__((alias("esp_core_dump_uart_write_start")));
esp_err_t esp_core_dump_write_end(core_dump_write_data_t *wr_data) __attribute__((alias("esp_core_dump_uart_write_end")));
esp_err_t esp_core_dump_write_data(core_dump_write_data_t *wr_data, void *data, uint32_t data_len) __attribute__((alias("esp_core_dump_uart_write_data")));
/* This function exists on every board, thus, we don't need to specify /* This function exists on every board, thus, we don't need to specify
* explicitly the header for each board. */ * explicitly the header for each board. */
int esp_clk_cpu_freq(void); int esp_clk_cpu_freq(void);
@@ -46,30 +51,28 @@ static void esp_core_dump_b64_encode(const uint8_t *src, uint32_t src_len, uint8
dst[j++] = '\0'; dst[j++] = '\0';
} }
static esp_err_t esp_core_dump_uart_write_start(core_dump_write_data_t *priv) static esp_err_t esp_core_dump_uart_write_start(core_dump_write_data_t *wr_data)
{ {
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
core_dump_write_data_t *wr_data = (core_dump_write_data_t *)priv;
ESP_COREDUMP_ASSERT(priv != NULL); ESP_COREDUMP_ASSERT(wr_data != NULL);
esp_core_dump_checksum_init(&wr_data->checksum_ctx); esp_core_dump_checksum_init(&wr_data->checksum_ctx);
ESP_COREDUMP_PRINT("================= CORE DUMP START =================\r\n"); ESP_COREDUMP_PRINT("================= CORE DUMP START =================\r\n");
return err; return err;
} }
static esp_err_t esp_core_dump_uart_write_prepare(core_dump_write_data_t *priv, uint32_t *data_len) static esp_err_t esp_core_dump_uart_write_prepare(core_dump_write_data_t *wr_data, uint32_t *data_len)
{ {
ESP_COREDUMP_ASSERT(data_len != NULL); ESP_COREDUMP_ASSERT(data_len != NULL);
*data_len += esp_core_dump_checksum_size(); *data_len += esp_core_dump_checksum_size();
return ESP_OK; return ESP_OK;
} }
static esp_err_t esp_core_dump_uart_write_end(core_dump_write_data_t *priv) static esp_err_t esp_core_dump_uart_write_end(core_dump_write_data_t *wr_data)
{ {
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
char buf[64 + 4] = { 0 }; char buf[64 + 4] = { 0 };
core_dump_checksum_bytes cs_addr = NULL; core_dump_checksum_bytes cs_addr = NULL;
core_dump_write_data_t *wr_data = (core_dump_write_data_t *)priv;
if (wr_data) { if (wr_data) {
size_t cs_len = esp_core_dump_checksum_finish(&wr_data->checksum_ctx, &cs_addr); size_t cs_len = esp_core_dump_checksum_finish(&wr_data->checksum_ctx, &cs_addr);
wr_data->off += cs_len; wr_data->off += cs_len;
@@ -85,13 +88,12 @@ static esp_err_t esp_core_dump_uart_write_end(core_dump_write_data_t *priv)
return err; return err;
} }
static esp_err_t esp_core_dump_uart_write_data(core_dump_write_data_t *priv, void * data, uint32_t data_len) static esp_err_t esp_core_dump_uart_write_data(core_dump_write_data_t *wr_data, void * data, uint32_t data_len)
{ {
esp_err_t err = ESP_OK; esp_err_t err = ESP_OK;
char buf[64 + 4] = { 0 }; char buf[64 + 4] = { 0 };
char *addr = data; char *addr = data;
char *end = addr + data_len; char *end = addr + data_len;
core_dump_write_data_t *wr_data = (core_dump_write_data_t *)priv;
ESP_COREDUMP_ASSERT(data != NULL); ESP_COREDUMP_ASSERT(data != NULL);
@@ -124,14 +126,6 @@ static int esp_core_dump_uart_get_char(void) {
void esp_core_dump_to_uart(panic_info_t *info) void esp_core_dump_to_uart(panic_info_t *info)
{ {
core_dump_write_data_t wr_data = { 0 };
core_dump_write_config_t wr_cfg = {
.prepare = esp_core_dump_uart_write_prepare,
.start = esp_core_dump_uart_write_start,
.end = esp_core_dump_uart_write_end,
.write = esp_core_dump_uart_write_data,
.priv = (void*)&wr_data
};
uint32_t tm_end = 0; uint32_t tm_end = 0;
uint32_t tm_cur = 0; uint32_t tm_cur = 0;
int ch = 0; int ch = 0;
@@ -155,7 +149,7 @@ void esp_core_dump_to_uart(panic_info_t *info)
ch = esp_core_dump_uart_get_char(); ch = esp_core_dump_uart_get_char();
} }
ESP_COREDUMP_LOGI("Print core dump to uart..."); ESP_COREDUMP_LOGI("Print core dump to uart...");
esp_core_dump_write(info, &wr_cfg); esp_core_dump_write(info);
ESP_COREDUMP_LOGI("Core dump has been written to uart."); ESP_COREDUMP_LOGI("Core dump has been written to uart.");
} }