From f6453b7938e20c1b1b52394c9799cf66dcfe7559 Mon Sep 17 00:00:00 2001 From: Zim Kalinowski Date: Wed, 15 Mar 2023 00:28:13 +0100 Subject: [PATCH] bootloader: fix and re-enable no-format warnings --- components/bootloader_support/CMakeLists.txt | 2 - .../bootloader_flash/src/flash_qio_mode.c | 8 ++-- .../src/bootloader_common.c | 4 +- .../src/bootloader_utility.c | 32 +++++++------- .../src/esp32/bootloader_esp32.c | 24 +++++------ .../src/esp32s2/bootloader_esp32s2.c | 24 +++++------ .../src/esp32s3/bootloader_esp32s3.c | 20 ++++----- .../bootloader_support/src/esp_image_format.c | 42 +++++++++---------- .../bootloader_support/src/flash_partitions.c | 4 +- .../secure_boot_signatures_app.c | 10 ++--- .../secure_boot_signatures_app.c | 10 ++--- 11 files changed, 89 insertions(+), 91 deletions(-) diff --git a/components/bootloader_support/CMakeLists.txt b/components/bootloader_support/CMakeLists.txt index 80fa6cacbf..d1b5db87dc 100644 --- a/components/bootloader_support/CMakeLists.txt +++ b/components/bootloader_support/CMakeLists.txt @@ -171,5 +171,3 @@ endif() if(BOOTLOADER_BUILD) target_link_libraries(${COMPONENT_LIB} INTERFACE "-u abort") endif() - -target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format") diff --git a/components/bootloader_support/bootloader_flash/src/flash_qio_mode.c b/components/bootloader_support/bootloader_flash/src/flash_qio_mode.c index 5b29186a02..957c2c338e 100644 --- a/components/bootloader_support/bootloader_flash/src/flash_qio_mode.c +++ b/components/bootloader_support/bootloader_flash/src/flash_qio_mode.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -76,7 +76,7 @@ void bootloader_enable_qio_mode(void) esp_rom_spiflash_wait_idle(&g_rom_flashchip); raw_flash_id = g_rom_flashchip.device_id; - ESP_LOGD(TAG, "Raw SPI flash chip id 0x%x", raw_flash_id); + ESP_LOGD(TAG, "Raw SPI flash chip id 0x%"PRIx32, raw_flash_id); mfg_id = (raw_flash_id >> 16) & 0xFF; flash_id = raw_flash_id & 0xFFFF; @@ -130,7 +130,7 @@ static esp_err_t enable_qio_mode(bootloader_flash_read_status_fn_t read_status_f esp_rom_spiflash_wait_idle(&g_rom_flashchip); status = read_status_fn(); - ESP_LOGD(TAG, "Initial flash chip status 0x%x", status); + ESP_LOGD(TAG, "Initial flash chip status 0x%"PRIx32, status); if ((status & (1 << status_qio_bit)) == 0) { bootloader_execute_flash_command(CMD_WREN, 0, 0, 0); @@ -139,7 +139,7 @@ static esp_err_t enable_qio_mode(bootloader_flash_read_status_fn_t read_status_f esp_rom_spiflash_wait_idle(&g_rom_flashchip); status = read_status_fn(); - ESP_LOGD(TAG, "Updated flash chip status 0x%x", status); + ESP_LOGD(TAG, "Updated flash chip status 0x%"PRIx32, status); if ((status & (1 << status_qio_bit)) == 0) { ESP_LOGE(TAG, "Failed to set QIE bit, not enabling QIO mode"); return ESP_FAIL; diff --git a/components/bootloader_support/src/bootloader_common.c b/components/bootloader_support/src/bootloader_common.c index 84af85a531..2817859497 100644 --- a/components/bootloader_support/src/bootloader_common.c +++ b/components/bootloader_support/src/bootloader_common.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2018-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2018-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -129,7 +129,7 @@ bool bootloader_common_erase_part_type_data(const char *list_erase, bool ota_dat marker = "no"; } - ESP_LOGI(TAG, "%2d %-16s data %08x %08x [%s]", i, partition->label, + ESP_LOGI(TAG, "%2d %-16s data %08"PRIx32" %08"PRIx32" [%s]", i, partition->label, partition->pos.offset, partition->pos.size, marker); } } diff --git a/components/bootloader_support/src/bootloader_utility.c b/components/bootloader_support/src/bootloader_utility.c index 78bc5c6cf7..389bdf2e19 100644 --- a/components/bootloader_support/src/bootloader_utility.c +++ b/components/bootloader_support/src/bootloader_utility.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2018-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2018-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -116,14 +116,14 @@ static esp_err_t read_otadata(const esp_partition_pos_t *ota_info, esp_ota_selec // partition table has OTA data partition if (ota_info->size < 2 * SPI_SEC_SIZE) { - ESP_LOGE(TAG, "ota_info partition size %d is too small (minimum %d bytes)", ota_info->size, (2 * SPI_SEC_SIZE)); + ESP_LOGE(TAG, "ota_info partition size %"PRIu32" is too small (minimum %d bytes)", ota_info->size, (2 * SPI_SEC_SIZE)); return ESP_FAIL; // can't proceed } - ESP_LOGD(TAG, "OTA data offset 0x%x", ota_info->offset); + ESP_LOGD(TAG, "OTA data offset 0x%"PRIx32, ota_info->offset); ota_select_map = bootloader_mmap(ota_info->offset, ota_info->size); if (!ota_select_map) { - ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", ota_info->offset, ota_info->size); + ESP_LOGE(TAG, "bootloader_mmap(0x%"PRIx32", 0x%"PRIx32") failed", ota_info->offset, ota_info->size); return ESP_FAIL; // can't proceed } @@ -144,7 +144,7 @@ esp_err_t bootloader_common_get_partition_description(const esp_partition_pos_t const uint32_t mmap_size = app_desc_offset + sizeof(esp_app_desc_t); const uint8_t *image = bootloader_mmap(partition->offset, mmap_size); if (image == NULL) { - ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", partition->offset, mmap_size); + ESP_LOGE(TAG, "bootloader_mmap(0x%"PRIx32", 0x%"PRIx32") failed", partition->offset, mmap_size); return ESP_FAIL; } @@ -243,7 +243,7 @@ bool bootloader_utility_load_partition_table(bootloader_state_t *bs) } /* print partition type info */ - ESP_LOGI(TAG, "%2d %-16s %-16s %02x %02x %08x %08x", i, partition->label, partition_usage, + ESP_LOGI(TAG, "%2d %-16s %-16s %02x %02x %08"PRIx32" %08"PRIx32, i, partition->label, partition_usage, partition->type, partition->subtype, partition->pos.offset, partition->pos.size); } @@ -347,7 +347,7 @@ static int get_active_otadata_with_check_anti_rollback(const bootloader_state_t ota_slot = ota_seq % bs->app_count; // Actual OTA partition selection if (check_anti_rollback(&bs->ota[ota_slot]) == false) { // invalid. This otadata[i] will not be selected as active. - ESP_LOGD(TAG, "OTA slot %d has an app with secure_version, this version is smaller than in the device. This OTA slot will not be selected.", ota_slot); + ESP_LOGD(TAG, "OTA slot %"PRIu32" has an app with secure_version, this version is smaller than in the device. This OTA slot will not be selected.", ota_slot); } else { sec_ver_valid_otadata[i] = true; } @@ -372,8 +372,8 @@ int bootloader_utility_get_selected_boot_partition(const bootloader_state_t *bs) } ota_has_initial_contents = false; - ESP_LOGD(TAG, "otadata[0]: sequence values 0x%08x", otadata[0].ota_seq); - ESP_LOGD(TAG, "otadata[1]: sequence values 0x%08x", otadata[1].ota_seq); + ESP_LOGD(TAG, "otadata[0]: sequence values 0x%08"PRIx32, otadata[0].ota_seq); + ESP_LOGD(TAG, "otadata[1]: sequence values 0x%08"PRIx32, otadata[1].ota_seq); #ifdef CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE bool write_encrypted = esp_flash_encryption_enabled(); @@ -390,7 +390,7 @@ int bootloader_utility_get_selected_boot_partition(const bootloader_state_t *bs) if ((bootloader_common_ota_select_invalid(&otadata[0]) && bootloader_common_ota_select_invalid(&otadata[1])) || bs->app_count == 0) { - ESP_LOGD(TAG, "OTA sequence numbers both empty (all-0xFF) or partition table does not have bootable ota_apps (app_count=%d)", bs->app_count); + ESP_LOGD(TAG, "OTA sequence numbers both empty (all-0xFF) or partition table does not have bootable ota_apps (app_count=%"PRIu32")", bs->app_count); if (bs->factory.offset != 0) { ESP_LOGI(TAG, "Defaulting to factory image"); boot_index = FACTORY_INDEX; @@ -409,7 +409,7 @@ int bootloader_utility_get_selected_boot_partition(const bootloader_state_t *bs) int active_otadata = bootloader_common_get_active_otadata(otadata); #else ESP_LOGI(TAG, "Enabled a check secure version of app for anti rollback"); - ESP_LOGI(TAG, "Secure version (from eFuse) = %d", esp_efuse_read_secure_version()); + ESP_LOGI(TAG, "Secure version (from eFuse) = %"PRIu32, esp_efuse_read_secure_version()); // When CONFIG_BOOTLOADER_APP_ANTI_ROLLBACK is enabled factory partition should not be in partition table, only two ota_app are there. if ((otadata[0].ota_seq == UINT32_MAX || otadata[0].crc != bootloader_common_ota_select_crc(&otadata[0])) && (otadata[1].ota_seq == UINT32_MAX || otadata[1].crc != bootloader_common_ota_select_crc(&otadata[1]))) { @@ -424,7 +424,7 @@ int bootloader_utility_get_selected_boot_partition(const bootloader_state_t *bs) ESP_LOGD(TAG, "Active otadata[%d]", active_otadata); uint32_t ota_seq = otadata[active_otadata].ota_seq - 1; // Raw OTA sequence number. May be more than # of OTA slots boot_index = ota_seq % bs->app_count; // Actual OTA partition selection - ESP_LOGD(TAG, "Mapping seq %d -> OTA slot %d", ota_seq, boot_index); + ESP_LOGD(TAG, "Mapping seq %"PRIu32" -> OTA slot %d", ota_seq, boot_index); #ifdef CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE if (otadata[active_otadata].ota_state == ESP_OTA_IMG_NEW) { ESP_LOGD(TAG, "otadata[%d] is selected as new and marked PENDING_VERIFY state", active_otadata); @@ -482,7 +482,7 @@ static void set_actual_ota_seq(const bootloader_state_t *bs, int index) bool write_encrypted = esp_flash_encryption_enabled(); write_otadata(&otadata, bs->ota_info.offset + FLASH_SECTOR_SIZE * 0, write_encrypted); - ESP_LOGI(TAG, "Set actual ota_seq=%d in otadata[0]", otadata.ota_seq); + ESP_LOGI(TAG, "Set actual ota_seq=%"PRIu32" in otadata[0]", otadata.ota_seq); #ifdef CONFIG_BOOTLOADER_APP_ANTI_ROLLBACK update_anti_rollback(&bs->ota[index]); #endif @@ -501,7 +501,7 @@ void bootloader_utility_load_boot_image_from_deep_sleep(void) if (partition != NULL) { esp_image_metadata_t image_data; if (bootloader_load_image_no_verify(partition, &image_data) == ESP_OK) { - ESP_LOGI(TAG, "Fast booting app from partition at offset 0x%x", partition->offset); + ESP_LOGI(TAG, "Fast booting app from partition at offset 0x%"PRIx32, partition->offset); bootloader_common_update_rtc_retain_mem(NULL, true); load_image(&image_data); } @@ -512,7 +512,7 @@ void bootloader_utility_load_boot_image_from_deep_sleep(void) } #endif -#define TRY_LOG_FORMAT "Trying partition index %d offs 0x%x size 0x%x" +#define TRY_LOG_FORMAT "Trying partition index %d offs 0x%"PRIx32" size 0x%"PRIx32 void bootloader_utility_load_boot_image(const bootloader_state_t *bs, int start_index) { @@ -906,7 +906,7 @@ static void set_cache_and_start_app( cache_hal_enable(CACHE_TYPE_ALL); #endif - ESP_LOGD(TAG, "start: 0x%08x", entry_addr); + ESP_LOGD(TAG, "start: 0x%08"PRIx32, entry_addr); bootloader_atexit(); typedef void (*entry_t)(void) __attribute__((noreturn)); entry_t entry = ((entry_t) entry_addr); diff --git a/components/bootloader_support/src/esp32/bootloader_esp32.c b/components/bootloader_support/src/esp32/bootloader_esp32.c index c2313b9f6e..0f76280a5e 100644 --- a/components/bootloader_support/src/esp32/bootloader_esp32.c +++ b/components/bootloader_support/src/esp32/bootloader_esp32.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2019-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -119,19 +119,19 @@ static void wdt_reset_info_dump(int cpu) if (DPORT_RECORD_PDEBUGINST_SZ(inst) == 0 && DPORT_RECORD_PDEBUGSTATUS_BBCAUSE(dstat) == DPORT_RECORD_PDEBUGSTATUS_BBCAUSE_WAITI) { - ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%x (waiti mode)", cpu_name, pc); + ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%"PRIx32" (waiti mode)", cpu_name, pc); } else { - ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%x", cpu_name, pc); + ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%"PRIx32, cpu_name, pc); } - ESP_LOGD(TAG, "WDT reset info: %s CPU STATUS 0x%08x", cpu_name, stat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PID 0x%08x", cpu_name, pid); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGINST 0x%08x", cpu_name, inst); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGSTATUS 0x%08x", cpu_name, dstat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGDATA 0x%08x", cpu_name, data); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGPC 0x%08x", cpu_name, pc); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0STAT 0x%08x", cpu_name, lsstat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0ADDR 0x%08x", cpu_name, lsaddr); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0DATA 0x%08x", cpu_name, lsdata); + ESP_LOGD(TAG, "WDT reset info: %s CPU STATUS 0x%08"PRIx32, cpu_name, stat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PID 0x%08"PRIx32, cpu_name, pid); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGINST 0x%08"PRIx32, cpu_name, inst); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGSTATUS 0x%08"PRIx32, cpu_name, dstat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGDATA 0x%08"PRIx32, cpu_name, data); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGPC 0x%08"PRIx32, cpu_name, pc); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0STAT 0x%08"PRIx32, cpu_name, lsstat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0ADDR 0x%08"PRIx32, cpu_name, lsaddr); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0DATA 0x%08"PRIx32, cpu_name, lsdata); } static void bootloader_check_wdt_reset(void) diff --git a/components/bootloader_support/src/esp32s2/bootloader_esp32s2.c b/components/bootloader_support/src/esp32s2/bootloader_esp32s2.c index c3a25ef54e..89fbb7fd7f 100644 --- a/components/bootloader_support/src/esp32s2/bootloader_esp32s2.c +++ b/components/bootloader_support/src/esp32s2/bootloader_esp32s2.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2019-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -67,19 +67,19 @@ static void wdt_reset_info_dump(int cpu) if (DPORT_RECORD_PDEBUGINST_SZ(inst) == 0 && DPORT_RECORD_PDEBUGSTATUS_BBCAUSE(dstat) == DPORT_RECORD_PDEBUGSTATUS_BBCAUSE_WAITI) { - ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%x (waiti mode)", cpu_name, pc); + ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%"PRIx32" (waiti mode)", cpu_name, pc); } else { - ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%x", cpu_name, pc); + ESP_LOGW(TAG, "WDT reset info: %s CPU PC=0x%"PRIx32, cpu_name, pc); } - ESP_LOGD(TAG, "WDT reset info: %s CPU STATUS 0x%08x", cpu_name, stat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PID 0x%08x", cpu_name, pid); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGINST 0x%08x", cpu_name, inst); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGSTATUS 0x%08x", cpu_name, dstat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGDATA 0x%08x", cpu_name, data); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGPC 0x%08x", cpu_name, pc); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0STAT 0x%08x", cpu_name, lsstat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0ADDR 0x%08x", cpu_name, lsaddr); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0DATA 0x%08x", cpu_name, lsdata); + ESP_LOGD(TAG, "WDT reset info: %s CPU STATUS 0x%08"PRIx32, cpu_name, stat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PID 0x%08"PRIx32, cpu_name, pid); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGINST 0x%08"PRIx32, cpu_name, inst); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGSTATUS 0x%08"PRIx32, cpu_name, dstat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGDATA 0x%08"PRIx32, cpu_name, data); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGPC 0x%08"PRIx32, cpu_name, pc); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0STAT 0x%08"PRIx32, cpu_name, lsstat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0ADDR 0x%08"PRIx32, cpu_name, lsaddr); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0DATA 0x%08"PRIx32, cpu_name, lsdata); } static void bootloader_check_wdt_reset(void) diff --git a/components/bootloader_support/src/esp32s3/bootloader_esp32s3.c b/components/bootloader_support/src/esp32s3/bootloader_esp32s3.c index 31a36b8098..9d98f22169 100644 --- a/components/bootloader_support/src/esp32s3/bootloader_esp32s3.c +++ b/components/bootloader_support/src/esp32s3/bootloader_esp32s3.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2020-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -83,15 +83,15 @@ static void wdt_reset_info_dump(int cpu) #endif } - ESP_LOGD(TAG, "WDT reset info: %s CPU STATUS 0x%08x", cpu_name, stat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PID 0x%08x", cpu_name, pid); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGINST 0x%08x", cpu_name, inst); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGSTATUS 0x%08x", cpu_name, dstat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGDATA 0x%08x", cpu_name, data); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGPC 0x%08x", cpu_name, pc); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0STAT 0x%08x", cpu_name, lsstat); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0ADDR 0x%08x", cpu_name, lsaddr); - ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0DATA 0x%08x", cpu_name, lsdata); + ESP_LOGD(TAG, "WDT reset info: %s CPU STATUS 0x%08"PRIx32, cpu_name, stat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PID 0x%08"PRIx32, cpu_name, pid); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGINST 0x%08"PRIx32, cpu_name, inst); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGSTATUS 0x%08"PRIx32, cpu_name, dstat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGDATA 0x%08"PRIx32, cpu_name, data); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGPC 0x%08"PRIx32, cpu_name, pc); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0STAT 0x%08"PRIx32, cpu_name, lsstat); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0ADDR 0x%08"PRIx32, cpu_name, lsaddr); + ESP_LOGD(TAG, "WDT reset info: %s CPU PDEBUGLS0DATA 0x%08"PRIx32, cpu_name, lsdata); } static void bootloader_check_wdt_reset(void) diff --git a/components/bootloader_support/src/esp_image_format.c b/components/bootloader_support/src/esp_image_format.c index c0882e7355..ef96101db0 100644 --- a/components/bootloader_support/src/esp_image_format.c +++ b/components/bootloader_support/src/esp_image_format.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -159,7 +159,7 @@ static esp_err_t image_load(esp_image_load_mode_t mode, const esp_partition_pos_ if (part->size > SIXTEEN_MB) { err = ESP_ERR_INVALID_ARG; - FAIL_LOAD("partition size 0x%x invalid, larger than 16MB", part->size); + FAIL_LOAD("partition size 0x%"PRIx32" invalid, larger than 16MB", part->size); } bootloader_sha256_handle_t *p_sha_handle = &sha_handle; @@ -317,7 +317,7 @@ static esp_err_t verify_image_header(uint32_t src_addr, const esp_image_header_t { esp_err_t err = ESP_OK; - ESP_LOGD(TAG, "image header: 0x%02x 0x%02x 0x%02x 0x%02x %08x", + ESP_LOGD(TAG, "image header: 0x%02x 0x%02x 0x%02x 0x%02x %08"PRIx32, image->magic, image->segment_count, image->spi_mode, @@ -325,7 +325,7 @@ static esp_err_t verify_image_header(uint32_t src_addr, const esp_image_header_t image->entry_addr); if (image->magic != ESP_IMAGE_HEADER_MAGIC) { - FAIL_LOAD("image at 0x%x has invalid magic byte (nothing flashed here?)", src_addr); + FAIL_LOAD("image at 0x%"PRIx32" has invalid magic byte (nothing flashed here?)", src_addr); } // Checking the chip revision header *will* print a bunch of other info @@ -334,7 +334,7 @@ static esp_err_t verify_image_header(uint32_t src_addr, const esp_image_header_t CHECK_ERR(bootloader_common_check_chip_validity(image, ESP_IMAGE_APPLICATION)); if (image->segment_count > ESP_IMAGE_MAX_SEGMENTS) { - FAIL_LOAD("image at 0x%x segment count %d exceeds max %d", src_addr, image->segment_count, ESP_IMAGE_MAX_SEGMENTS); + FAIL_LOAD("image at 0x%"PRIx32" segment count %d exceeds max %d", src_addr, image->segment_count, ESP_IMAGE_MAX_SEGMENTS); } return err; err: @@ -481,7 +481,7 @@ static esp_err_t process_image_header(esp_image_metadata_t *data, uint32_t part_ bzero(data, sizeof(esp_image_metadata_t)); data->start_addr = part_offset; - ESP_LOGD(TAG, "reading image header @ 0x%x", data->start_addr); + ESP_LOGD(TAG, "reading image header @ 0x%"PRIx32, data->start_addr); CHECK_ERR(bootloader_flash_read(data->start_addr, &data->image, sizeof(esp_image_header_t), true)); if (do_verify) { @@ -510,7 +510,7 @@ static esp_err_t process_segments(esp_image_metadata_t *data, bool silent, bool uint32_t next_addr = start_segments; for (int i = 0; i < data->image.segment_count; i++) { esp_image_segment_header_t *header = &data->segments[i]; - ESP_LOGV(TAG, "loading segment header %d at offset 0x%x", i, next_addr); + ESP_LOGV(TAG, "loading segment header %d at offset 0x%"PRIx32, i, next_addr); CHECK_ERR(process_segment(i, next_addr, header, silent, do_load, sha_handle, checksum)); next_addr += sizeof(esp_image_segment_header_t); data->segment_data[i] = next_addr; @@ -523,7 +523,7 @@ static esp_err_t process_segments(esp_image_metadata_t *data, bool silent, bool } data->image_len += end_addr - start_segments; - ESP_LOGV(TAG, "image start 0x%08x end of last section 0x%08x", data->start_addr, end_addr); + ESP_LOGV(TAG, "image start 0x%08"PRIx32" end of last section 0x%08"PRIx32, data->start_addr, end_addr); return err; err: if (err == ESP_OK) { @@ -539,7 +539,7 @@ static esp_err_t process_segment(int index, uint32_t flash_addr, esp_image_segme /* read segment header */ err = bootloader_flash_read(flash_addr, header, sizeof(esp_image_segment_header_t), true); if (err != ESP_OK) { - ESP_LOGE(TAG, "bootloader_flash_read failed at 0x%08x", flash_addr); + ESP_LOGE(TAG, "bootloader_flash_read failed at 0x%08"PRIx32, flash_addr); return err; } if (sha_handle != NULL) { @@ -550,19 +550,19 @@ static esp_err_t process_segment(int index, uint32_t flash_addr, esp_image_segme uint32_t data_len = header->data_len; uint32_t data_addr = flash_addr + sizeof(esp_image_segment_header_t); - ESP_LOGV(TAG, "segment data length 0x%x data starts 0x%x", data_len, data_addr); + ESP_LOGV(TAG, "segment data length 0x%"PRIx32" data starts 0x%"PRIx32, data_len, data_addr); CHECK_ERR(verify_segment_header(index, header, data_addr, silent)); if (data_len % 4 != 0) { - FAIL_LOAD("unaligned segment length 0x%x", data_len); + FAIL_LOAD("unaligned segment length 0x%"PRIx32, data_len); } bool is_mapping = should_map(load_addr); do_load = do_load && should_load(load_addr); if (!silent) { - ESP_LOGI(TAG, "segment %d: paddr=%08x vaddr=%08x size=%05xh (%6d) %s", + ESP_LOGI(TAG, "segment %d: paddr=%08"PRIx32" vaddr=%08x size=%05"PRIx32"h (%6"PRIu32") %s", index, data_addr, load_addr, data_len, data_len, (do_load) ? "load" : (is_mapping) ? "map" : ""); @@ -579,7 +579,7 @@ static esp_err_t process_segment(int index, uint32_t flash_addr, esp_image_segme #endif // BOOTLOADER_BUILD uint32_t free_page_count = bootloader_mmap_get_free_pages(); - ESP_LOGD(TAG, "free data page_count 0x%08x", free_page_count); + ESP_LOGD(TAG, "free data page_count 0x%08"PRIx32, free_page_count); uint32_t data_len_remain = data_len; while (data_len_remain > 0) { @@ -616,7 +616,7 @@ static esp_err_t process_segment_data(intptr_t load_addr, uint32_t data_addr, ui const uint32_t *data = (const uint32_t *)bootloader_mmap(data_addr, data_len); if (!data) { - ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", + ESP_LOGE(TAG, "bootloader_mmap(0x%"PRIx32", 0x%"PRIx32") failed", data_addr, data_len); return ESP_FAIL; } @@ -674,7 +674,7 @@ static esp_err_t verify_segment_header(int index, const esp_image_segment_header if ((segment->data_len & 3) != 0 || segment->data_len >= SIXTEEN_MB) { if (!silent) { - ESP_LOGE(TAG, "invalid segment length 0x%x", segment->data_len); + ESP_LOGE(TAG, "invalid segment length 0x%"PRIx32, segment->data_len); } return ESP_ERR_IMAGE_INVALID; } @@ -685,12 +685,12 @@ static esp_err_t verify_segment_header(int index, const esp_image_segment_header /* Check that flash cache mapped segment aligns correctly from flash to its mapped address, relative to the 64KB page mapping size. */ - ESP_LOGV(TAG, "segment %d map_segment %d segment_data_offs 0x%x load_addr 0x%x", + ESP_LOGV(TAG, "segment %d map_segment %d segment_data_offs 0x%"PRIx32" load_addr 0x%"PRIx32, index, map_segment, segment_data_offs, load_addr); if (map_segment && ((segment_data_offs % SPI_FLASH_MMU_PAGE_SIZE) != (load_addr % SPI_FLASH_MMU_PAGE_SIZE))) { if (!silent) { - ESP_LOGE(TAG, "Segment %d load address 0x%08x, doesn't match data 0x%08x", + ESP_LOGE(TAG, "Segment %d load address 0x%08"PRIx32", doesn't match data 0x%08"PRIx32, index, load_addr, segment_data_offs); } return ESP_ERR_IMAGE_INVALID; @@ -726,18 +726,18 @@ static bool should_load(uint32_t load_addr) if (!load_rtc_memory) { #if SOC_RTC_FAST_MEM_SUPPORTED if (load_addr >= SOC_RTC_IRAM_LOW && load_addr < SOC_RTC_IRAM_HIGH) { - ESP_LOGD(TAG, "Skipping RTC fast memory segment at 0x%08x", load_addr); + ESP_LOGD(TAG, "Skipping RTC fast memory segment at 0x%08"PRIx32, load_addr); return false; } if (load_addr >= SOC_RTC_DRAM_LOW && load_addr < SOC_RTC_DRAM_HIGH) { - ESP_LOGD(TAG, "Skipping RTC fast memory segment at 0x%08x", load_addr); + ESP_LOGD(TAG, "Skipping RTC fast memory segment at 0x%08"PRIx32, load_addr); return false; } #endif #if SOC_RTC_SLOW_MEM_SUPPORTED if (load_addr >= SOC_RTC_DATA_LOW && load_addr < SOC_RTC_DATA_HIGH) { - ESP_LOGD(TAG, "Skipping RTC slow memory segment at 0x%08x", load_addr); + ESP_LOGD(TAG, "Skipping RTC slow memory segment at 0x%08"PRIx32, load_addr); return false; } #endif @@ -808,7 +808,7 @@ static esp_err_t process_appended_hash_and_sig(esp_image_metadata_t *data, uint3 const uint32_t full_image_len = end + sig_block_len; if (full_image_len > part_len) { - FAIL_LOAD("Image length %d doesn't fit in partition length %d", full_image_len, part_len); + FAIL_LOAD("Image length %"PRIu32" doesn't fit in partition length %"PRIu32, full_image_len, part_len); } return err; err: diff --git a/components/bootloader_support/src/flash_partitions.c b/components/bootloader_support/src/flash_partitions.c index d043941c81..69cf92cbc0 100644 --- a/components/bootloader_support/src/flash_partitions.c +++ b/components/bootloader_support/src/flash_partitions.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -25,7 +25,7 @@ esp_err_t esp_partition_table_verify(const esp_partition_info_t *partition_table const esp_partition_pos_t *pos = &part->pos; if (pos->offset > chip_size || pos->offset + pos->size > chip_size) { if (log_errors) { - ESP_LOGE(TAG, "partition %d invalid - offset 0x%x size 0x%x exceeds flash chip size 0x%x", + ESP_LOGE(TAG, "partition %d invalid - offset 0x%"PRIx32" size 0x%"PRIx32" exceeds flash chip size 0x%"PRIx32, num_parts, pos->offset, pos->size, chip_size); } return ESP_ERR_INVALID_SIZE; diff --git a/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_app.c b/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_app.c index facbb17314..e62e881a66 100644 --- a/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_app.c +++ b/components/bootloader_support/src/secure_boot_v1/secure_boot_signatures_app.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -34,18 +34,18 @@ esp_err_t esp_secure_boot_verify_signature(uint32_t src_addr, uint32_t length) uint8_t verified_digest[ESP_SECURE_BOOT_DIGEST_LEN]; const esp_secure_boot_sig_block_t *sigblock; - ESP_LOGD(TAG, "verifying signature src_addr 0x%x length 0x%x", src_addr, length); + ESP_LOGD(TAG, "verifying signature src_addr 0x%"PRIx32" length 0x%"PRIx32, src_addr, length); esp_err_t err = bootloader_sha256_flash_contents(src_addr, length, digest); if (err != ESP_OK) { - ESP_LOGE(TAG, "Digest calculation failed 0x%x, 0x%x", src_addr, length); + ESP_LOGE(TAG, "Digest calculation failed 0x%"PRIx32", 0x%"PRIx32, src_addr, length); return err; } // Map the signature block and verify the signature sigblock = (const esp_secure_boot_sig_block_t *)bootloader_mmap(src_addr + length, sizeof(esp_secure_boot_sig_block_t)); if (sigblock == NULL) { - ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", src_addr + length, sizeof(esp_secure_boot_sig_block_t)); + ESP_LOGE(TAG, "bootloader_mmap(0x%"PRIx32", 0x%x) failed", src_addr + length, sizeof(esp_secure_boot_sig_block_t)); return ESP_FAIL; } err = esp_secure_boot_verify_ecdsa_signature_block(sigblock, digest, verified_digest); @@ -71,7 +71,7 @@ esp_err_t esp_secure_boot_verify_ecdsa_signature_block(const esp_secure_boot_sig } if (sig_block->version != 0) { - ESP_LOGE(TAG, "image has invalid signature version field 0x%08x (image without a signature?)", sig_block->version); + ESP_LOGE(TAG, "image has invalid signature version field 0x%08"PRIx32" (image without a signature?)", sig_block->version); return ESP_FAIL; } diff --git a/components/bootloader_support/src/secure_boot_v2/secure_boot_signatures_app.c b/components/bootloader_support/src/secure_boot_v2/secure_boot_signatures_app.c index b214d07857..7c4ad07f10 100644 --- a/components/bootloader_support/src/secure_boot_v2/secure_boot_signatures_app.c +++ b/components/bootloader_support/src/secure_boot_v2/secure_boot_signatures_app.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -70,7 +70,7 @@ esp_err_t esp_secure_boot_get_signature_blocks_for_running_app(bool digest_publi // metadata.image_len doesn't include any padding to start of the signature sector, so pad it here size_t sig_block_addr = metadata.start_addr + ALIGN_UP(metadata.image_len, FLASH_SECTOR_SIZE); - ESP_LOGD(TAG, "reading signatures for app address 0x%x sig block address 0x%x", part_pos.offset, sig_block_addr); + ESP_LOGD(TAG, "reading signatures for app address 0x%"PRIx32" sig block address 0x%x", part_pos.offset, sig_block_addr); for (unsigned i = 0; i < SECURE_BOOT_NUM_BLOCKS; i++) { ets_secure_boot_sig_block_t block; size_t addr = sig_block_addr + sizeof(ets_secure_boot_sig_block_t) * i; @@ -132,17 +132,17 @@ esp_err_t esp_secure_boot_verify_signature(uint32_t src_addr, uint32_t length) /* Rounding off length to the upper 4k boundary */ uint32_t padded_length = ALIGN_UP(length, FLASH_SECTOR_SIZE); - ESP_LOGD(TAG, "verifying signature src_addr 0x%x length 0x%x", src_addr, length); + ESP_LOGD(TAG, "verifying signature src_addr 0x%"PRIx32" length 0x%"PRIx32, src_addr, length); esp_err_t err = bootloader_sha256_flash_contents(src_addr, padded_length, digest); if (err != ESP_OK) { - ESP_LOGE(TAG, "Digest calculation failed 0x%x, 0x%x", src_addr, padded_length); + ESP_LOGE(TAG, "Digest calculation failed 0x%"PRIx32", 0x%"PRIx32, src_addr, padded_length); return err; } const ets_secure_boot_signature_t *sig_block = bootloader_mmap(src_addr + padded_length, sizeof(ets_secure_boot_signature_t)); if (sig_block == NULL) { - ESP_LOGE(TAG, "Failed to mmap data at offset 0x%x", src_addr + padded_length); + ESP_LOGE(TAG, "Failed to mmap data at offset 0x%"PRIx32, src_addr + padded_length); return ESP_FAIL; }