304 lines
No EOL
12 KiB
C
304 lines
No EOL
12 KiB
C
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include "sdkconfig.h"
|
|
#include "esp_core_dump_priv.h"
|
|
#include "core_dump_elf.h"
|
|
|
|
const static DRAM_ATTR char TAG[] __attribute__((unused)) = "esp_core_dump_common";
|
|
|
|
#if CONFIG_ESP32_COREDUMP_DATA_FORMAT_BIN
|
|
|
|
static inline uint32_t esp_core_dump_get_tcb_len(void)
|
|
{
|
|
if (COREDUMP_TCB_SIZE % sizeof(uint32_t)) {
|
|
return ((COREDUMP_TCB_SIZE / sizeof(uint32_t) + 1) * sizeof(uint32_t));
|
|
}
|
|
return COREDUMP_TCB_SIZE;
|
|
}
|
|
|
|
static inline uint32_t esp_core_dump_get_memory_len(uint32_t stack_start, uint32_t stack_end)
|
|
{
|
|
uint32_t len = stack_end - stack_start;
|
|
// Take stack padding into account
|
|
return (len + sizeof(uint32_t) - 1) & ~(sizeof(uint32_t) - 1);
|
|
}
|
|
|
|
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;
|
|
uint32_t stk_vaddr, stk_len;
|
|
uint32_t stk_paddr = esp_core_dump_get_stack(task, &stk_vaddr, &stk_len);
|
|
|
|
stk_len = esp_core_dump_get_memory_len(stk_vaddr, stk_vaddr+stk_len);
|
|
|
|
// Save TCB address, stack base and stack top addr
|
|
err = write_cfg->write(write_cfg->priv, (void*)task, sizeof(core_dump_task_header_t));
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to write task header, error=%d!", err);
|
|
return err;
|
|
}
|
|
// Save TCB block
|
|
err = write_cfg->write(write_cfg->priv, task->tcb_addr, esp_core_dump_get_tcb_len());
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to write TCB, error=%d!", err);
|
|
return err;
|
|
}
|
|
// Save task stack
|
|
err = write_cfg->write(write_cfg->priv, (void*)stk_paddr, stk_len);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to write stack for task (TCB:%x), stack_start=%x, error=%d!",
|
|
task->tcb_addr,
|
|
stk_vaddr,
|
|
err);
|
|
return err;
|
|
}
|
|
|
|
ESP_COREDUMP_LOG_PROCESS("Task (TCB:%x) dump is saved.",
|
|
task->tcb_addr);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t esp_core_dump_save_mem_segment(core_dump_write_config_t* write_cfg,
|
|
core_dump_mem_seg_header_t* seg)
|
|
{
|
|
esp_err_t err = ESP_FAIL;
|
|
|
|
if (!esp_core_dump_mem_seg_is_sane(seg->start, seg->size)) {
|
|
ESP_COREDUMP_LOGE("Failed to write memory segment, (%x, %lu)!",
|
|
seg->start, seg->size);
|
|
return ESP_FAIL;
|
|
}
|
|
// Save TCB address, stack base and stack top addr
|
|
err = write_cfg->write(write_cfg->priv, (void*)seg, sizeof(core_dump_mem_seg_header_t));
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to write memory segment header, error=%d!", err);
|
|
return err;
|
|
}
|
|
// Save memory contents
|
|
err = write_cfg->write(write_cfg->priv, (void*)seg->start, seg->size);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to write memory segment, (%x, %lu), error=%d!",
|
|
seg->start, seg->size, err);
|
|
return err;
|
|
}
|
|
ESP_COREDUMP_LOG_PROCESS("Memory segment (%x, %lu) is saved.",
|
|
seg->start, seg->size);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t esp_core_dump_write_binary(void *frame, core_dump_write_config_t *write_cfg)
|
|
{
|
|
esp_err_t err;
|
|
static core_dump_task_header_t *tasks[CONFIG_ESP32_CORE_DUMP_MAX_TASKS_NUM];
|
|
uint32_t task_num, tcb_sz = esp_core_dump_get_tcb_len();
|
|
uint32_t data_len = 0, task_id;
|
|
int curr_task_index = COREDUMP_CURR_TASK_NOT_FOUND;
|
|
core_dump_header_t hdr;
|
|
core_dump_mem_seg_header_t interrupted_task_stack;
|
|
|
|
task_num = esp_core_dump_get_tasks_snapshot(tasks, CONFIG_ESP32_CORE_DUMP_MAX_TASKS_NUM);
|
|
ESP_COREDUMP_LOGI("Found tasks: %d!", task_num);
|
|
|
|
// Verifies all tasks in the snapshot
|
|
|
|
for (task_id = 0; task_id < task_num; task_id++) {
|
|
bool is_current_task = false, stack_is_valid = false;
|
|
bool tcb_is_valid = esp_core_dump_check_task(frame, tasks[task_id], &is_current_task, &stack_is_valid);
|
|
// Check if task tcb or stack is corrupted
|
|
if (!tcb_is_valid || !stack_is_valid) {
|
|
// If tcb or stack for task is corrupted count task as broken
|
|
write_cfg->bad_tasks_num++;
|
|
}
|
|
if (is_current_task) {
|
|
curr_task_index = task_id; // save current crashed task index in the snapshot
|
|
ESP_COREDUMP_LOG_PROCESS("Task #%d (TCB:%x) is first crashed task.",
|
|
task_id,
|
|
tasks[task_id]->tcb_addr);
|
|
}
|
|
// Increase core dump size by task stack size
|
|
uint32_t stk_vaddr, stk_len;
|
|
esp_core_dump_get_stack(tasks[task_id], &stk_vaddr, &stk_len);
|
|
data_len += esp_core_dump_get_memory_len(stk_vaddr, stk_vaddr+stk_len);
|
|
// Add tcb size
|
|
data_len += (tcb_sz + sizeof(core_dump_task_header_t));
|
|
}
|
|
|
|
if (esp_core_dump_in_isr_context()) {
|
|
interrupted_task_stack.start = tasks[curr_task_index]->stack_start;
|
|
interrupted_task_stack.size = esp_core_dump_get_memory_len(tasks[curr_task_index]->stack_start, tasks[curr_task_index]->stack_end);
|
|
// size of the task's stack has been already taken into account, also addresses have also been checked
|
|
data_len += sizeof(core_dump_mem_seg_header_t);
|
|
tasks[curr_task_index]->stack_start = (uint32_t)frame;
|
|
tasks[curr_task_index]->stack_end = esp_core_dump_get_isr_stack_end();
|
|
ESP_COREDUMP_LOG_PROCESS("Add ISR stack %lu to %lu", tasks[curr_task_index]->stack_end - tasks[curr_task_index]->stack_start, data_len);
|
|
// take into account size of the ISR stack
|
|
data_len += esp_core_dump_get_memory_len(tasks[curr_task_index]->stack_start, tasks[curr_task_index]->stack_end);
|
|
}
|
|
|
|
// Check if current task TCB is broken
|
|
if (curr_task_index == COREDUMP_CURR_TASK_NOT_FOUND) {
|
|
ESP_COREDUMP_LOG_PROCESS("The current crashed task is broken.");
|
|
curr_task_index = 0;
|
|
}
|
|
|
|
// Add user memory region header size
|
|
data_len += esp_core_dump_get_user_ram_segments() * sizeof(core_dump_mem_seg_header_t);
|
|
for (coredump_region_t i = COREDUMP_MEMORY_START; i < COREDUMP_MEMORY_MAX; i++) {
|
|
uint32_t start = 0;
|
|
int data_sz = esp_core_dump_get_user_ram_info(i, &start);
|
|
|
|
if (data_sz < 0) {
|
|
ESP_COREDUMP_LOGE("Invalid memory segment size");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
if (data_sz > 0) {
|
|
data_len += esp_core_dump_get_memory_len(start, start + data_sz);
|
|
}
|
|
}
|
|
|
|
// Add core dump header size
|
|
data_len += sizeof(core_dump_header_t);
|
|
|
|
ESP_COREDUMP_LOG_PROCESS("Core dump length=%lu, tasks processed: %d, broken tasks: %d",
|
|
data_len, task_num, write_cfg->bad_tasks_num);
|
|
// Prepare write
|
|
if (write_cfg->prepare) {
|
|
err = write_cfg->prepare(write_cfg->priv, &data_len);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to prepare core dump, error=%d!", err);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
// Write start
|
|
if (write_cfg->start) {
|
|
err = write_cfg->start(write_cfg->priv);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to start core dump, error=%d!", err);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
// Write header
|
|
hdr.data_len = data_len;
|
|
hdr.version = COREDUMP_VERSION;
|
|
hdr.tasks_num = task_num; // save all the tasks in snapshot even broken
|
|
hdr.mem_segs_num = 0;
|
|
if (xPortInterruptedFromISRContext()) {
|
|
hdr.mem_segs_num++; // stack of interrupted task
|
|
}
|
|
hdr.mem_segs_num += esp_core_dump_get_user_ram_segments(); // stack of user mapped memory
|
|
hdr.tcb_sz = tcb_sz;
|
|
err = write_cfg->write(write_cfg->priv, &hdr, sizeof(core_dump_header_t));
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to write core dump header error=%d!", err);
|
|
return err;
|
|
}
|
|
|
|
// Write first crashed task data first (not always first task in the snapshot)
|
|
err = esp_core_dump_save_task(write_cfg, tasks[curr_task_index]);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to save first crashed task #%d (TCB:%x), error=%d!",
|
|
curr_task_index, tasks[curr_task_index]->tcb_addr, err);
|
|
return err;
|
|
}
|
|
|
|
// Write all other tasks in the snapshot
|
|
for (task_id = 0; task_id < task_num; task_id++) {
|
|
// Skip first crashed task
|
|
if (task_id == curr_task_index) {
|
|
continue;
|
|
}
|
|
err = esp_core_dump_save_task(write_cfg, tasks[task_id]);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to save core dump task #%d (TCB:%x), error=%d!",
|
|
task_id, tasks[curr_task_index]->tcb_addr, err);
|
|
return err;
|
|
}
|
|
}
|
|
if (xPortInterruptedFromISRContext()) {
|
|
err = esp_core_dump_save_mem_segment(write_cfg, &interrupted_task_stack);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to save interrupted task stack, error=%d!", err);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
// save user memory regions
|
|
if (esp_core_dump_get_user_ram_segments() > 0) {
|
|
core_dump_mem_seg_header_t user_ram_stack_size;
|
|
for (coredump_region_t i = COREDUMP_MEMORY_START; i < COREDUMP_MEMORY_MAX; i++) {
|
|
uint32_t start = 0;
|
|
int data_sz = esp_core_dump_get_user_ram_info(i, &start);
|
|
|
|
if (data_sz < 0) {
|
|
ESP_COREDUMP_LOGE("Invalid memory segment size");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
if (data_sz > 0) {
|
|
user_ram_stack_size.start = start;
|
|
user_ram_stack_size.size = esp_core_dump_get_memory_len(start, start + data_sz);;
|
|
err = esp_core_dump_save_mem_segment(write_cfg, &user_ram_stack_size);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to save user memory data, error=%d!", err);
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write end
|
|
if (write_cfg->end) {
|
|
err = write_cfg->end(write_cfg->priv);
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Failed to end core dump error=%d!", err);
|
|
return err;
|
|
}
|
|
}
|
|
if (write_cfg->bad_tasks_num) {
|
|
ESP_COREDUMP_LOGE("Found %d broken tasks!", write_cfg->bad_tasks_num);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
#endif
|
|
|
|
inline void esp_core_dump_write(void *frame, core_dump_write_config_t *write_cfg)
|
|
{
|
|
esp_core_dump_setup_stack();
|
|
|
|
#ifndef CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE
|
|
esp_err_t err = ESP_ERR_NOT_SUPPORTED;
|
|
#if CONFIG_ESP32_COREDUMP_DATA_FORMAT_BIN
|
|
err = esp_core_dump_write_binary(frame, write_cfg);
|
|
#elif CONFIG_ESP32_COREDUMP_DATA_FORMAT_ELF
|
|
err = esp_core_dump_write_elf(frame, write_cfg);
|
|
#endif
|
|
if (err != ESP_OK) {
|
|
ESP_COREDUMP_LOGE("Core dump write binary failed with error=%d", err);
|
|
}
|
|
#endif
|
|
|
|
esp_core_dump_report_stack_usage();
|
|
}
|
|
|
|
void __attribute__((weak)) esp_core_dump_init(void)
|
|
{
|
|
/* do nothing by default */
|
|
} |