feedc0de/esp-idf
1
0
Fork 0
forked from espressif/esp-idf
Code Pull Requests Activity

Storage: Fixed formatting of esp_partition Linux code

Browse Source
This commit is contained in:
Martin Vychodil
2023-02-28 23:47:11 +01:00
committed by BOT
parent e9e388a085
commit abc4d67a9d
3 changed files with 38 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
components/esp_partition/Kconfig
View File

@@ -1,10 +1,10 @@
menu "Partition API Configuration" menu "Partition API Configuration"
# This option enables gathering statistics and flash wear levelling simulation.
# Linux target only (host tests).
config ESP_PARTITION_ENABLE_STATS config ESP_PARTITION_ENABLE_STATS
bool bool "Host test statistics enabled"
depends on IDF_TARGET_LINUX depends on IDF_TARGET_LINUX
default n default n
help
This option enables gathering host test statistics and SPI flash wear levelling simulation.
endmenu endmenu

2
components/esp_partition/host_test/partition_api_test/sdkconfig.defaults
View File

@@ -1,5 +1,5 @@
CONFIG_IDF_TARGET="linux" CONFIG_IDF_TARGET="linux"
IDF_TARGET_LINUX=y CONFIG_IDF_TARGET_LINUX=y
CONFIG_COMPILER_CXX_EXCEPTIONS=y CONFIG_COMPILER_CXX_EXCEPTIONS=y
CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n
CONFIG_UNITY_ENABLE_FIXTURE=y CONFIG_UNITY_ENABLE_FIXTURE=y

68
components/esp_partition/partition_linux.c
View File

@@ -102,19 +102,19 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
// temporary file is used only if control structure doesn't specify file name. // temporary file is used only if control structure doesn't specify file name.
bool open_existing_file = false; bool open_existing_file = false;
if(strlen(s_esp_partition_file_mmap_ctrl_input.flash_file_name) > 0) { if (strlen(s_esp_partition_file_mmap_ctrl_input.flash_file_name) > 0) {
// Open existing file. If size or partition table file were specified, raise errors // Open existing file. If size or partition table file were specified, raise errors
if(s_esp_partition_file_mmap_ctrl_input.flash_file_size > 0) { if (s_esp_partition_file_mmap_ctrl_input.flash_file_size > 0) {
ESP_LOGE(TAG, "Flash emulation file size: %u was specified while together with the file name: %s (illegal). Use file size = 0", ESP_LOGE(TAG, "Flash emulation file size: %u was specified while together with the file name: %s (illegal). Use file size = 0",
s_esp_partition_file_mmap_ctrl_input.flash_file_size, s_esp_partition_file_mmap_ctrl_input.flash_file_size,
s_esp_partition_file_mmap_ctrl_input.flash_file_name); s_esp_partition_file_mmap_ctrl_input.flash_file_name);
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
if(strlen(s_esp_partition_file_mmap_ctrl_input.partition_file_name) > 0) { if (strlen(s_esp_partition_file_mmap_ctrl_input.partition_file_name) > 0) {
ESP_LOGE(TAG, "Partition file name: %s was specified together with the flash emulation file name: %s (illegal). Use empty partition file name", ESP_LOGE(TAG, "Partition file name: %s was specified together with the flash emulation file name: %s (illegal). Use empty partition file name",
s_esp_partition_file_mmap_ctrl_input.partition_file_name, s_esp_partition_file_mmap_ctrl_input.partition_file_name,
s_esp_partition_file_mmap_ctrl_input.flash_file_name); s_esp_partition_file_mmap_ctrl_input.flash_file_name);
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
@@ -131,22 +131,22 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
bool has_len = (s_esp_partition_file_mmap_ctrl_input.flash_file_size > 0); bool has_len = (s_esp_partition_file_mmap_ctrl_input.flash_file_size > 0);
// conflicting input // conflicting input
if(has_partfile != has_len) { if (has_partfile != has_len) {
ESP_LOGE(TAG, "Invalid combination of Partition file name: %s flash file size: %u was specified. Use either both parameters or none.", ESP_LOGE(TAG, "Invalid combination of Partition file name: %s flash file size: %u was specified. Use either both parameters or none.",
s_esp_partition_file_mmap_ctrl_input.partition_file_name, s_esp_partition_file_mmap_ctrl_input.partition_file_name,
s_esp_partition_file_mmap_ctrl_input.flash_file_size); s_esp_partition_file_mmap_ctrl_input.flash_file_size);
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
// check if partition file is present, if not, use default // check if partition file is present, if not, use default
if(!has_partfile) { if (!has_partfile) {
strlcpy(s_esp_partition_file_mmap_ctrl_act.partition_file_name, "build/partition_table/partition-table.bin", sizeof(s_esp_partition_file_mmap_ctrl_act.partition_file_name)); strlcpy(s_esp_partition_file_mmap_ctrl_act.partition_file_name, "build/partition_table/partition-table.bin", sizeof(s_esp_partition_file_mmap_ctrl_act.partition_file_name));
} else { } else {
strlcpy(s_esp_partition_file_mmap_ctrl_act.partition_file_name, s_esp_partition_file_mmap_ctrl_input.partition_file_name, sizeof(s_esp_partition_file_mmap_ctrl_act.partition_file_name)); strlcpy(s_esp_partition_file_mmap_ctrl_act.partition_file_name, s_esp_partition_file_mmap_ctrl_input.partition_file_name, sizeof(s_esp_partition_file_mmap_ctrl_act.partition_file_name));
} }
// check if flash size is present, if not set to default // check if flash size is present, if not set to default
if(!has_len) { if (!has_len) {
s_esp_partition_file_mmap_ctrl_act.flash_file_size = ESP_PARTITION_DEFAULT_EMULATED_FLASH_SIZE; s_esp_partition_file_mmap_ctrl_act.flash_file_size = ESP_PARTITION_DEFAULT_EMULATED_FLASH_SIZE;
} else { } else {
s_esp_partition_file_mmap_ctrl_act.flash_file_size = s_esp_partition_file_mmap_ctrl_input.flash_file_size; s_esp_partition_file_mmap_ctrl_act.flash_file_size = s_esp_partition_file_mmap_ctrl_input.flash_file_size;
@@ -158,7 +158,7 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
if(open_existing_file) { if (open_existing_file) {
s_spiflash_mem_file_fd = open(s_esp_partition_file_mmap_ctrl_act.flash_file_name, O_RDWR); s_spiflash_mem_file_fd = open(s_esp_partition_file_mmap_ctrl_act.flash_file_name, O_RDWR);
@@ -170,7 +170,7 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
do { do {
// seek to the end // seek to the end
off_t size = lseek(s_spiflash_mem_file_fd, 0L, SEEK_END); off_t size = lseek(s_spiflash_mem_file_fd, 0L, SEEK_END);
if(size < 0) { if (size < 0) {
ESP_LOGE(TAG, "Failed to seek in SPI FLASH emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno)); ESP_LOGE(TAG, "Failed to seek in SPI FLASH emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno));
ret = ESP_ERR_NOT_FINISHED; ret = ESP_ERR_NOT_FINISHED;
break; break;
@@ -180,7 +180,7 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
// seek to beginning // seek to beginning
size = lseek(s_spiflash_mem_file_fd, 0L, SEEK_SET); size = lseek(s_spiflash_mem_file_fd, 0L, SEEK_SET);
if(size < 0) { if (size < 0) {
ESP_LOGE(TAG, "Failed to seek in SPI FLASH emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno)); ESP_LOGE(TAG, "Failed to seek in SPI FLASH emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno));
ret = ESP_ERR_NOT_FINISHED; ret = ESP_ERR_NOT_FINISHED;
break; break;
@@ -192,7 +192,7 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
ret = ESP_ERR_NOT_FINISHED; ret = ESP_ERR_NOT_FINISHED;
break; break;
} }
} while(false); } while (false);
} else { } else {
//create temporary file to hold complete SPIFLASH size //create temporary file to hold complete SPIFLASH size
s_spiflash_mem_file_fd = mkstemp(s_esp_partition_file_mmap_ctrl_act.flash_file_name); s_spiflash_mem_file_fd = mkstemp(s_esp_partition_file_mmap_ctrl_act.flash_file_name);
@@ -240,11 +240,11 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
ESP_LOGV(TAG, "Using partition table file %s (size: %d B):", s_esp_partition_file_mmap_ctrl_act.partition_file_name, partition_table_file_size); ESP_LOGV(TAG, "Using partition table file %s (size: %d B):", s_esp_partition_file_mmap_ctrl_act.partition_file_name, partition_table_file_size);
// check whether partition table fits into the memory mapped file // check whether partition table fits into the memory mapped file
if(partition_table_file_size + ESP_PARTITION_TABLE_OFFSET > s_esp_partition_file_mmap_ctrl_act.flash_file_size) { if (partition_table_file_size + ESP_PARTITION_TABLE_OFFSET > s_esp_partition_file_mmap_ctrl_act.flash_file_size) {
ESP_LOGE(TAG, "Flash file: %s (size: %d B) cannot hold partition table requiring %d B", ESP_LOGE(TAG, "Flash file: %s (size: %d B) cannot hold partition table requiring %d B",
s_esp_partition_file_mmap_ctrl_act.flash_file_name, s_esp_partition_file_mmap_ctrl_act.flash_file_name,
s_esp_partition_file_mmap_ctrl_act.flash_file_size, s_esp_partition_file_mmap_ctrl_act.flash_file_size,
partition_table_file_size + ESP_PARTITION_TABLE_OFFSET); partition_table_file_size + ESP_PARTITION_TABLE_OFFSET);
ret = ESP_ERR_INVALID_SIZE; ret = ESP_ERR_INVALID_SIZE;
break; break;
} }
@@ -265,11 +265,11 @@ esp_err_t esp_partition_file_mmap(const uint8_t **part_desc_addr_start)
ret = ESP_ERR_INVALID_STATE; ret = ESP_ERR_INVALID_STATE;
break; break;
} }
} while(false); } while (false);
} }
if (ret != ESP_OK) { if (ret != ESP_OK) {
if(close(s_spiflash_mem_file_fd)) { if (close(s_spiflash_mem_file_fd)) {
ESP_LOGE(TAG, "Failed to close() SPIFLASH memory emulation file: %s", strerror(errno)); ESP_LOGE(TAG, "Failed to close() SPIFLASH memory emulation file: %s", strerror(errno));
} }
s_spiflash_mem_file_fd = -1; s_spiflash_mem_file_fd = -1;
@@ -325,7 +325,7 @@ esp_err_t esp_partition_file_munmap(void)
if (s_esp_partition_file_mmap_ctrl_act.flash_file_size == 0) { if (s_esp_partition_file_mmap_ctrl_act.flash_file_size == 0) {
return ESP_ERR_INVALID_SIZE; return ESP_ERR_INVALID_SIZE;
} }
if(s_spiflash_mem_file_fd == -1) { if (s_spiflash_mem_file_fd == -1) {
return ESP_ERR_NOT_FOUND; return ESP_ERR_NOT_FOUND;
} }
@@ -343,14 +343,14 @@ esp_err_t esp_partition_file_munmap(void)
} }
// close memory mapped file // close memory mapped file
if(close(s_spiflash_mem_file_fd)) { if (close(s_spiflash_mem_file_fd)) {
ESP_LOGE(TAG, "Failed to close() SPIFLASH memory emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno)); ESP_LOGE(TAG, "Failed to close() SPIFLASH memory emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno));
return ESP_ERR_INVALID_RESPONSE; return ESP_ERR_INVALID_RESPONSE;
} }
if(s_esp_partition_file_mmap_ctrl_input.remove_dump) { if (s_esp_partition_file_mmap_ctrl_input.remove_dump) {
// delete spi flash file // delete spi flash file
if(remove(s_esp_partition_file_mmap_ctrl_act.flash_file_name) != 0) { if (remove(s_esp_partition_file_mmap_ctrl_act.flash_file_name) != 0) {
ESP_LOGE(TAG, "Failed to remove() SPI FLASH memory emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno)); ESP_LOGE(TAG, "Failed to remove() SPI FLASH memory emulation file %s: %s", s_esp_partition_file_mmap_ctrl_act.flash_file_name, strerror(errno));
return ESP_ERR_INVALID_RESPONSE; return ESP_ERR_INVALID_RESPONSE;
} }
@@ -517,12 +517,12 @@ void esp_partition_munmap(esp_partition_mmap_handle_t handle __attribute__((unus
{ {
} }
esp_partition_file_mmap_ctrl_t* esp_partition_get_file_mmap_ctrl_input(void) esp_partition_file_mmap_ctrl_t *esp_partition_get_file_mmap_ctrl_input(void)
{ {
return &s_esp_partition_file_mmap_ctrl_input; return &s_esp_partition_file_mmap_ctrl_input;
} }
esp_partition_file_mmap_ctrl_t* esp_partition_get_file_mmap_ctrl_act(void) esp_partition_file_mmap_ctrl_t *esp_partition_get_file_mmap_ctrl_act(void)
{ {
return &s_esp_partition_file_mmap_ctrl_act; return &s_esp_partition_file_mmap_ctrl_act;
} }
@@ -584,11 +584,11 @@ static bool esp_partition_hook_write(const void *dstAddr, const size_t size)
size_t write_cycles = size / 4; size_t write_cycles = size / 4;
// check whether power off simulation is active for write // check whether power off simulation is active for write
if(s_esp_partition_emulated_power_off_counter != SIZE_MAX && if (s_esp_partition_emulated_power_off_counter != SIZE_MAX &&
s_esp_partition_emulated_power_off_counter & ESP_PARTITION_FAIL_AFTER_MODE_WRITE) { s_esp_partition_emulated_power_off_counter & ESP_PARTITION_FAIL_AFTER_MODE_WRITE) {
// check if power down happens during this call // check if power down happens during this call
if(s_esp_partition_emulated_power_off_counter >= write_cycles) { if (s_esp_partition_emulated_power_off_counter >= write_cycles) {
// OK // OK
s_esp_partition_emulated_power_off_counter -= write_cycles; s_esp_partition_emulated_power_off_counter -= write_cycles;
} else { } else {
@@ -633,11 +633,11 @@ static bool esp_partition_hook_erase(const void *dstAddr, const size_t size)
bool ret_val = true; bool ret_val = true;
// check whether power off simulation is active for erase // check whether power off simulation is active for erase
if(s_esp_partition_emulated_power_off_counter != SIZE_MAX && if (s_esp_partition_emulated_power_off_counter != SIZE_MAX &&
s_esp_partition_emulated_power_off_counter & ESP_PARTITION_FAIL_AFTER_MODE_ERASE) { s_esp_partition_emulated_power_off_counter & ESP_PARTITION_FAIL_AFTER_MODE_ERASE) {
// check if power down happens during this call // check if power down happens during this call
if(s_esp_partition_emulated_power_off_counter >= sector_count) { if (s_esp_partition_emulated_power_off_counter >= sector_count) {
// OK // OK
s_esp_partition_emulated_power_off_counter -= sector_count; s_esp_partition_emulated_power_off_counter -= sector_count;
} else { } else {