blackbeard420/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf synced 2025-03-09 17:19:09 -04:00
Code Issues Projects Releases Wiki Activity

change(coredump): make sure consistency with written data and calculated checksum

Browse Source
This commit is contained in:
Erhan Kurubas 2024-12-17 11:33:42 +03:00
parent 94f3007db0
commit a2023c6241
1 changed files with 7 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
components/espcoredump/src/core_dump_flash.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
*/ */
@ -92,20 +92,15 @@ static esp_err_t esp_core_dump_flash_write_data(core_dump_write_data_t* priv, ui
uint32_t written = 0; uint32_t written = 0;
uint32_t wr_sz = 0; uint32_t wr_sz = 0;
/* Make sure that the partition is large enough to hold the data. */ /* Make sure that the partition is large enough to store both the cached and new data. */
ESP_COREDUMP_ASSERT((wr_data->off + data_size) < s_core_flash_config.partition.size); ESP_COREDUMP_ASSERT((wr_data->off + wr_data->cached_bytes + data_size) < s_core_flash_config.partition.size);
if (wr_data->cached_bytes) { while (data_size > 0) {
/* Some bytes are in the cache, let's continue filling the cache /* Calculate the maximum amount of bytes we can still fill the cache with. */
* with the data received as parameter. Let's calculate the maximum wr_sz = MIN(data_size, COREDUMP_CACHE_SIZE - wr_data->cached_bytes);
* amount of bytes we can still fill the cache with. */
if ((COREDUMP_CACHE_SIZE - wr_data->cached_bytes) > data_size)
wr_sz = data_size;
else
wr_sz = COREDUMP_CACHE_SIZE - wr_data->cached_bytes;
/* Append wr_sz bytes from data parameter to the cache. */ /* Append wr_sz bytes from data parameter to the cache. */
memcpy(&wr_data->cached_data[wr_data->cached_bytes], data, wr_sz); memcpy(&wr_data->cached_data[wr_data->cached_bytes], data + written, wr_sz);
wr_data->cached_bytes += wr_sz; wr_data->cached_bytes += wr_sz;
if (wr_data->cached_bytes == COREDUMP_CACHE_SIZE) { if (wr_data->cached_bytes == COREDUMP_CACHE_SIZE) {
@ -133,47 +128,6 @@ static esp_err_t esp_core_dump_flash_write_data(core_dump_write_data_t* priv, ui
data_size -= wr_sz; data_size -= wr_sz;
} }
/* Figure out how many bytes we can write onto the flash directly, without
* using the cache. In our case the cache size is a multiple of the flash's
* minimum writing block size, so we will use it for our calculation.
* For example, if COREDUMP_CACHE_SIZE equals 32, here are interesting
* values:
* +---------+-----------------------+
* | | data_size |
* +---------+---+----+----+----+----+
* | | 0 | 31 | 32 | 40 | 64 |
* +---------+---+----+----+----+----+
* | (blocks | 0 | 0 | 1 | 1 | 2) |
* +---------+---+----+----+----+----+
* | wr_sz | 0 | 0 | 32 | 32 | 64 |
* +---------+---+----+----+----+----+
*/
wr_sz = (data_size / COREDUMP_CACHE_SIZE) * COREDUMP_CACHE_SIZE;
if (wr_sz) {
/* Write the contiguous amount of bytes to the flash,
* without using the cache */
err = esp_core_dump_flash_custom_write(s_core_flash_config.partition.start + wr_data->off, data + written, wr_sz);
if (err != ESP_OK) {
ESP_COREDUMP_LOGE("Failed to write data to flash (%d)!", err);
return err;
}
/* Update the checksum with the newly written bytes */
esp_core_dump_checksum_update(wr_data->checksum_ctx, data + written, wr_sz);
wr_data->off += wr_sz;
written += wr_sz;
data_size -= wr_sz;
}
if (data_size > 0) {
/* There still some bytes from the data parameter that need to be sent,
* append it to cache in order to write them later. (i.e. when there
* will be enough bytes to fill the cache) */
memcpy(&wr_data->cached_data, data + written, data_size);
wr_data->cached_bytes = data_size;
}
return ESP_OK; return ESP_OK;
} }