From 897bb554823d8a048edd88799ef16dc3895d4027 Mon Sep 17 00:00:00 2001 From: "GOPTIONS\\pfrost" Date: Mon, 1 Apr 2019 15:13:55 +0100 Subject: [PATCH 1/2] nvs: Append _t to nvs_handle & nvs_open_mode types Merges https://github.com/espressif/esp-idf/pull/3239/ --- components/app_update/test/test_switch_ota.c | 2 +- .../bt/bluedroid/bta/gatt/bta_gattc_co.c | 10 +-- components/bt/bluedroid/osi/config.c | 10 +-- components/esp_wifi/src/phy_init.c | 14 ++-- components/lwip/port/esp32/netif/dhcp_state.c | 6 +- components/nvs_flash/include/nvs.h | 72 +++++++++++-------- components/nvs_flash/src/nvs_api.cpp | 64 ++++++++--------- components/nvs_flash/test/test_nvs.c | 20 +++--- .../nvs_flash/test_nvs_host/test_nvs.cpp | 70 +++++++++--------- .../nvs_rw_blob/main/nvs_blob_example_main.c | 6 +- .../main/nvs_value_example_main.c | 2 +- .../console/components/cmd_nvs/cmd_nvs.c | 10 +-- examples/system/ulp/main/ulp_example_main.c | 2 +- 13 files changed, 149 insertions(+), 139 deletions(-) diff --git a/components/app_update/test/test_switch_ota.c b/components/app_update/test/test_switch_ota.c index 0c0b0e75e..d8cb2d621 100644 --- a/components/app_update/test/test_switch_ota.c +++ b/components/app_update/test/test_switch_ota.c @@ -387,7 +387,7 @@ static void test_flow4(void) boot_count++; ESP_LOGI(TAG, "boot count %d", boot_count); const esp_partition_t *cur_app = get_running_firmware(); - nvs_handle handle = 0; + nvs_handle_t handle = 0; int boot_count_nvs = 0; switch (boot_count) { case 2: diff --git a/components/bt/bluedroid/bta/gatt/bta_gattc_co.c b/components/bt/bluedroid/bta/gatt/bta_gattc_co.c index 37befab80..c11fb9589 100644 --- a/components/bt/bluedroid/bta/gatt/bta_gattc_co.c +++ b/components/bt/bluedroid/bta/gatt/bta_gattc_co.c @@ -77,11 +77,11 @@ static void cacheReset(BD_ADDR bda) static const char *cache_key = "gattc_cache_key"; static const char *cache_addr = "cache_addr_tab"; -nvs_handle nvs_fp; +nvs_handle_t nvs_fp; typedef struct { //save the service data in the list according to the address - nvs_handle cache_fp; + nvs_handle_t cache_fp; BOOLEAN is_open; BD_ADDR addr; hash_key_t hash_key; @@ -90,7 +90,7 @@ typedef struct { typedef struct { //save the address list in the cache - nvs_handle addr_fp; + nvs_handle_t addr_fp; BOOLEAN is_open; UINT8 num_addr; cache_addr_info_t cache_addr[MAX_DEVICE_IN_CACHE]; @@ -377,7 +377,7 @@ void bta_gattc_co_cache_reset(BD_ADDR server_bda) void bta_gattc_co_cache_addr_init(void) { - nvs_handle fp; + nvs_handle_t fp; esp_err_t err_code; UINT8 num_addr; UINT8 *p_buf = osi_malloc(MAX_ADDR_LIST_CACHE_BUF); @@ -520,7 +520,7 @@ void bta_gattc_co_cache_addr_save(BD_ADDR bd_addr, hash_key_t hash_key) memcpy(cache_env.cache_addr[num - 1].hash_key, hash_key, sizeof(hash_key_t)); } - nvs_handle *fp = &cache_env.addr_fp; + nvs_handle_t *fp = &cache_env.addr_fp; UINT16 length = num*(sizeof(BD_ADDR) + sizeof(hash_key_t)); for (UINT8 i = 0; i < num; i++) { diff --git a/components/bt/bluedroid/osi/config.c b/components/bt/bluedroid/osi/config.c index 55a3b3d4b..9e60f5c10 100644 --- a/components/bt/bluedroid/osi/config.c +++ b/components/bt/bluedroid/osi/config.c @@ -48,7 +48,7 @@ struct config_t { // Empty definition; this type is aliased to list_node_t. struct config_section_iter_t {}; -static void config_parse(nvs_handle fp, config_t *config); +static void config_parse(nvs_handle_t fp, config_t *config); static section_t *section_new(const char *name); static void section_free(void *ptr); @@ -89,7 +89,7 @@ config_t *config_new(const char *filename) } esp_err_t err; - nvs_handle fp; + nvs_handle_t fp; err = nvs_open(filename, NVS_READWRITE, &fp); if (err != ESP_OK) { if (err == ESP_ERR_NVS_NOT_INITIALIZED) { @@ -331,7 +331,7 @@ static int get_config_size(const config_t *config) return total_size; } -static int get_config_size_from_flash(nvs_handle fp) +static int get_config_size_from_flash(nvs_handle_t fp) { assert(fp != 0); @@ -384,7 +384,7 @@ bool config_save(const config_t *config, const char *filename) esp_err_t err; int err_code = 0; - nvs_handle fp; + nvs_handle_t fp; char *line = osi_calloc(1024); const size_t keyname_bufsz = sizeof(CONFIG_KEY) + 5 + 1; // including log10(sizeof(i)) char *keyname = osi_calloc(keyname_bufsz); @@ -507,7 +507,7 @@ static char *trim(char *str) return str; } -static void config_parse(nvs_handle fp, config_t *config) +static void config_parse(nvs_handle_t fp, config_t *config) { assert(fp != 0); assert(config != NULL); diff --git a/components/esp_wifi/src/phy_init.c b/components/esp_wifi/src/phy_init.c index 2fade4e35..1490356f3 100644 --- a/components/esp_wifi/src/phy_init.c +++ b/components/esp_wifi/src/phy_init.c @@ -436,15 +436,15 @@ static const char* PHY_CAL_VERSION_KEY = "cal_version"; static const char* PHY_CAL_MAC_KEY = "cal_mac"; static const char* PHY_CAL_DATA_KEY = "cal_data"; -static esp_err_t load_cal_data_from_nvs_handle(nvs_handle handle, +static esp_err_t load_cal_data_from_nvs_handle(nvs_handle_t handle, esp_phy_calibration_data_t* out_cal_data); -static esp_err_t store_cal_data_to_nvs_handle(nvs_handle handle, +static esp_err_t store_cal_data_to_nvs_handle(nvs_handle_t handle, const esp_phy_calibration_data_t* cal_data); esp_err_t esp_phy_load_cal_data_from_nvs(esp_phy_calibration_data_t* out_cal_data) { - nvs_handle handle; + nvs_handle_t handle; esp_err_t err = nvs_open(PHY_NAMESPACE, NVS_READONLY, &handle); if (err == ESP_ERR_NVS_NOT_INITIALIZED) { ESP_LOGE(TAG, "%s: NVS has not been initialized. " @@ -461,7 +461,7 @@ esp_err_t esp_phy_load_cal_data_from_nvs(esp_phy_calibration_data_t* out_cal_dat esp_err_t esp_phy_store_cal_data_to_nvs(const esp_phy_calibration_data_t* cal_data) { - nvs_handle handle; + nvs_handle_t handle; esp_err_t err = nvs_open(PHY_NAMESPACE, NVS_READWRITE, &handle); if (err != ESP_OK) { ESP_LOGD(TAG, "%s: failed to open NVS namespace (0x%x)", __func__, err); @@ -476,7 +476,7 @@ esp_err_t esp_phy_store_cal_data_to_nvs(const esp_phy_calibration_data_t* cal_da esp_err_t esp_phy_erase_cal_data_in_nvs(void) { - nvs_handle handle; + nvs_handle_t handle; esp_err_t err = nvs_open(PHY_NAMESPACE, NVS_READWRITE, &handle); if (err != ESP_OK) { ESP_LOGE(TAG, "%s: failed to open NVS phy namespace (0x%x)", __func__, err); @@ -498,7 +498,7 @@ esp_err_t esp_phy_erase_cal_data_in_nvs(void) return err; } -static esp_err_t load_cal_data_from_nvs_handle(nvs_handle handle, +static esp_err_t load_cal_data_from_nvs_handle(nvs_handle_t handle, esp_phy_calibration_data_t* out_cal_data) { esp_err_t err; @@ -547,7 +547,7 @@ static esp_err_t load_cal_data_from_nvs_handle(nvs_handle handle, return ESP_OK; } -static esp_err_t store_cal_data_to_nvs_handle(nvs_handle handle, +static esp_err_t store_cal_data_to_nvs_handle(nvs_handle_t handle, const esp_phy_calibration_data_t* cal_data) { esp_err_t err; diff --git a/components/lwip/port/esp32/netif/dhcp_state.c b/components/lwip/port/esp32/netif/dhcp_state.c index 9301ff3b0..ede094bd4 100644 --- a/components/lwip/port/esp32/netif/dhcp_state.c +++ b/components/lwip/port/esp32/netif/dhcp_state.c @@ -33,7 +33,7 @@ _Static_assert(sizeof(interface_key) / sizeof(char*) == TCPIP_ADAPTER_IF_MAX, bool dhcp_ip_addr_restore(void *netif) { - nvs_handle nvs; + nvs_handle_t nvs; bool err = false; struct netif *net = (struct netif *)netif; struct dhcp *dhcp = netif_dhcp_data(net); @@ -54,7 +54,7 @@ bool dhcp_ip_addr_restore(void *netif) void dhcp_ip_addr_store(void *netif) { - nvs_handle nvs; + nvs_handle_t nvs; struct netif *net = (struct netif *)netif; struct dhcp *dhcp = netif_dhcp_data(net); uint32_t ip_addr = dhcp->offered_ip_addr.addr; @@ -73,7 +73,7 @@ void dhcp_ip_addr_store(void *netif) void dhcp_ip_addr_erase(void *netif) { - nvs_handle nvs; + nvs_handle_t nvs; struct netif *net = (struct netif *)netif; esp_interface_t netif_id = tcpip_adapter_get_esp_if(net); diff --git a/components/nvs_flash/include/nvs.h b/components/nvs_flash/include/nvs.h index 4fe440860..13f5b9552 100644 --- a/components/nvs_flash/include/nvs.h +++ b/components/nvs_flash/include/nvs.h @@ -26,7 +26,12 @@ extern "C" { /** * Opaque pointer type representing non-volatile storage handle */ -typedef uint32_t nvs_handle; +typedef uint32_t nvs_handle_t; + +/* + * Pre-IDF V4.0 uses nvs_handle, so leaving the original typedef here for compatibility. + */ +typedef nvs_handle_t nvs_handle; #define ESP_ERR_NVS_BASE 0x1100 /*!< Starting number of error codes */ #define ESP_ERR_NVS_NOT_INITIALIZED (ESP_ERR_NVS_BASE + 0x01) /*!< The storage driver is not initialized */ @@ -57,14 +62,19 @@ typedef uint32_t nvs_handle; #define ESP_ERR_NVS_CONTENT_DIFFERS (ESP_ERR_NVS_BASE + 0x18) /*!< Internal error; never returned by nvs API functions. NVS key is different in comparison */ #define NVS_DEFAULT_PART_NAME "nvs" /*!< Default partition name of the NVS partition in the partition table */ + /** * @brief Mode of opening the non-volatile storage - * */ typedef enum { NVS_READONLY, /*!< Read only */ NVS_READWRITE /*!< Read and write */ -} nvs_open_mode; +} nvs_open_mode_t; + +/* + * Pre-IDF V4.0 uses nvs_open_mode, so leaving the original typedef here for compatibility. + */ +typedef nvs_open_mode_t nvs_open_mode typedef enum { NVS_TYPE_U8 = 0x01, @@ -107,7 +117,7 @@ typedef enum { * - ESP_ERR_NVS_INVALID_NAME if namespace name doesn't satisfy constraints * - other error codes from the underlying storage driver */ -esp_err_t nvs_open(const char* name, nvs_open_mode open_mode, nvs_handle *out_handle); +esp_err_t nvs_open(const char* name, nvs_open_mode_t open_mode, nvs_handle_t *out_handle); /** * @brief Open non-volatile storage with a given namespace from specified partition @@ -135,7 +145,7 @@ esp_err_t nvs_open(const char* name, nvs_open_mode open_mode, nvs_handle *out_ha * - ESP_ERR_NVS_INVALID_NAME if namespace name doesn't satisfy constraints * - other error codes from the underlying storage driver */ -esp_err_t nvs_open_from_partition(const char *part_name, const char* name, nvs_open_mode open_mode, nvs_handle *out_handle); +esp_err_t nvs_open_from_partition(const char *part_name, const char* name, nvs_open_mode_t open_mode, nvs_handle_t *out_handle); /**@{*/ /** @@ -166,15 +176,15 @@ esp_err_t nvs_open_from_partition(const char *part_name, const char* name, nvs_o * flash operation doesn't fail again. * - ESP_ERR_NVS_VALUE_TOO_LONG if the string value is too long */ -esp_err_t nvs_set_i8 (nvs_handle handle, const char* key, int8_t value); -esp_err_t nvs_set_u8 (nvs_handle handle, const char* key, uint8_t value); -esp_err_t nvs_set_i16 (nvs_handle handle, const char* key, int16_t value); -esp_err_t nvs_set_u16 (nvs_handle handle, const char* key, uint16_t value); -esp_err_t nvs_set_i32 (nvs_handle handle, const char* key, int32_t value); -esp_err_t nvs_set_u32 (nvs_handle handle, const char* key, uint32_t value); -esp_err_t nvs_set_i64 (nvs_handle handle, const char* key, int64_t value); -esp_err_t nvs_set_u64 (nvs_handle handle, const char* key, uint64_t value); -esp_err_t nvs_set_str (nvs_handle handle, const char* key, const char* value); +esp_err_t nvs_set_i8 (nvs_handle_t handle, const char* key, int8_t value); +esp_err_t nvs_set_u8 (nvs_handle_t handle, const char* key, uint8_t value); +esp_err_t nvs_set_i16 (nvs_handle_t handle, const char* key, int16_t value); +esp_err_t nvs_set_u16 (nvs_handle_t handle, const char* key, uint16_t value); +esp_err_t nvs_set_i32 (nvs_handle_t handle, const char* key, int32_t value); +esp_err_t nvs_set_u32 (nvs_handle_t handle, const char* key, uint32_t value); +esp_err_t nvs_set_i64 (nvs_handle_t handle, const char* key, int64_t value); +esp_err_t nvs_set_u64 (nvs_handle_t handle, const char* key, uint64_t value); +esp_err_t nvs_set_str (nvs_handle_t handle, const char* key, const char* value); /**@}*/ /** @@ -204,7 +214,7 @@ esp_err_t nvs_set_str (nvs_handle handle, const char* key, const char* value); * flash operation doesn't fail again. * - ESP_ERR_NVS_VALUE_TOO_LONG if the value is too long */ -esp_err_t nvs_set_blob(nvs_handle handle, const char* key, const void* value, size_t length); +esp_err_t nvs_set_blob(nvs_handle_t handle, const char* key, const void* value, size_t length); /**@{*/ /** @@ -244,14 +254,14 @@ esp_err_t nvs_set_blob(nvs_handle handle, const char* key, const void* value, si * - ESP_ERR_NVS_INVALID_NAME if key name doesn't satisfy constraints * - ESP_ERR_NVS_INVALID_LENGTH if length is not sufficient to store data */ -esp_err_t nvs_get_i8 (nvs_handle handle, const char* key, int8_t* out_value); -esp_err_t nvs_get_u8 (nvs_handle handle, const char* key, uint8_t* out_value); -esp_err_t nvs_get_i16 (nvs_handle handle, const char* key, int16_t* out_value); -esp_err_t nvs_get_u16 (nvs_handle handle, const char* key, uint16_t* out_value); -esp_err_t nvs_get_i32 (nvs_handle handle, const char* key, int32_t* out_value); -esp_err_t nvs_get_u32 (nvs_handle handle, const char* key, uint32_t* out_value); -esp_err_t nvs_get_i64 (nvs_handle handle, const char* key, int64_t* out_value); -esp_err_t nvs_get_u64 (nvs_handle handle, const char* key, uint64_t* out_value); +esp_err_t nvs_get_i8 (nvs_handle_t handle, const char* key, int8_t* out_value); +esp_err_t nvs_get_u8 (nvs_handle_t handle, const char* key, uint8_t* out_value); +esp_err_t nvs_get_i16 (nvs_handle_t handle, const char* key, int16_t* out_value); +esp_err_t nvs_get_u16 (nvs_handle_t handle, const char* key, uint16_t* out_value); +esp_err_t nvs_get_i32 (nvs_handle_t handle, const char* key, int32_t* out_value); +esp_err_t nvs_get_u32 (nvs_handle_t handle, const char* key, uint32_t* out_value); +esp_err_t nvs_get_i64 (nvs_handle_t handle, const char* key, int64_t* out_value); +esp_err_t nvs_get_u64 (nvs_handle_t handle, const char* key, uint64_t* out_value); /**@}*/ /** @@ -311,8 +321,8 @@ esp_err_t nvs_get_u64 (nvs_handle handle, const char* key, uint64_t* out_value); * - ESP_ERR_NVS_INVALID_LENGTH if length is not sufficient to store data */ /**@{*/ -esp_err_t nvs_get_str (nvs_handle handle, const char* key, char* out_value, size_t* length); -esp_err_t nvs_get_blob(nvs_handle handle, const char* key, void* out_value, size_t* length); +esp_err_t nvs_get_str (nvs_handle_t handle, const char* key, char* out_value, size_t* length); +esp_err_t nvs_get_blob(nvs_handle_t handle, const char* key, void* out_value, size_t* length); /**@}*/ /** @@ -334,7 +344,7 @@ esp_err_t nvs_get_blob(nvs_handle handle, const char* key, void* out_value, size * - ESP_ERR_NVS_NOT_FOUND if the requested key doesn't exist * - other error codes from the underlying storage driver */ -esp_err_t nvs_erase_key(nvs_handle handle, const char* key); +esp_err_t nvs_erase_key(nvs_handle_t handle, const char* key); /** * @brief Erase all key-value pairs in a namespace @@ -350,7 +360,7 @@ esp_err_t nvs_erase_key(nvs_handle handle, const char* key); * - ESP_ERR_NVS_READ_ONLY if handle was opened as read only * - other error codes from the underlying storage driver */ -esp_err_t nvs_erase_all(nvs_handle handle); +esp_err_t nvs_erase_all(nvs_handle_t handle); /** * @brief Write any pending changes to non-volatile storage @@ -367,7 +377,7 @@ esp_err_t nvs_erase_all(nvs_handle handle); * - ESP_ERR_NVS_INVALID_HANDLE if handle has been closed or is NULL * - other error codes from the underlying storage driver */ -esp_err_t nvs_commit(nvs_handle handle); +esp_err_t nvs_commit(nvs_handle_t handle); /** * @brief Close the storage handle and free any allocated resources @@ -380,7 +390,7 @@ esp_err_t nvs_commit(nvs_handle handle); * * @param[in] handle Storage handle to close */ -void nvs_close(nvs_handle handle); +void nvs_close(nvs_handle_t handle); /** * @note Info about storage space NVS. @@ -436,7 +446,7 @@ esp_err_t nvs_get_stats(const char* part_name, nvs_stats_t* nvs_stats); * * \code{c} * // Example of nvs_get_used_entry_count() to get amount of all key-value pairs in one namespace: - * nvs_handle handle; + * nvs_handle_t handle; * nvs_open("namespace1", NVS_READWRITE, &handle); * ... * size_t used_entries; @@ -463,7 +473,7 @@ esp_err_t nvs_get_stats(const char* part_name, nvs_stats_t* nvs_stats); * - Other error codes from the underlying storage driver. * Return param used_entries will be filled 0. */ -esp_err_t nvs_get_used_entry_count(nvs_handle handle, size_t* used_entries); +esp_err_t nvs_get_used_entry_count(nvs_handle_t handle, size_t* used_entries); #ifdef __cplusplus } // extern "C" diff --git a/components/nvs_flash/src/nvs_api.cpp b/components/nvs_flash/src/nvs_api.cpp index da905922d..6898227dc 100644 --- a/components/nvs_flash/src/nvs_api.cpp +++ b/components/nvs_flash/src/nvs_api.cpp @@ -55,7 +55,7 @@ public: { } - nvs_handle mHandle; + nvs_handle_t mHandle; uint8_t mReadOnly; uint8_t mNsIndex; nvs::Storage* mStoragePtr; @@ -253,7 +253,7 @@ extern "C" esp_err_t nvs_flash_deinit(void) return nvs_flash_deinit_partition(NVS_DEFAULT_PART_NAME); } -static esp_err_t nvs_find_ns_handle(nvs_handle handle, HandleEntry& entry) +static esp_err_t nvs_find_ns_handle(nvs_handle_t handle, HandleEntry& entry) { auto it = find_if(begin(s_nvs_handles), end(s_nvs_handles), [=](HandleEntry& e) -> bool { return e.mHandle == handle; @@ -265,7 +265,7 @@ static esp_err_t nvs_find_ns_handle(nvs_handle handle, HandleEntry& entry) return ESP_OK; } -extern "C" esp_err_t nvs_open_from_partition(const char *part_name, const char* name, nvs_open_mode open_mode, nvs_handle *out_handle) +extern "C" esp_err_t nvs_open_from_partition(const char *part_name, const char* name, nvs_open_mode_t open_mode, nvs_handle_t *out_handle) { Lock lock; ESP_LOGD(TAG, "%s %s %d", __func__, name, open_mode); @@ -290,7 +290,7 @@ extern "C" esp_err_t nvs_open_from_partition(const char *part_name, const char* return ESP_OK; } -extern "C" esp_err_t nvs_open(const char* name, nvs_open_mode open_mode, nvs_handle *out_handle) +extern "C" esp_err_t nvs_open(const char* name, nvs_open_mode_t open_mode, nvs_handle_t *out_handle) { if (s_nvs_storage_list.size() == 0) { return ESP_ERR_NVS_NOT_INITIALIZED; @@ -299,7 +299,7 @@ extern "C" esp_err_t nvs_open(const char* name, nvs_open_mode open_mode, nvs_han return nvs_open_from_partition(NVS_DEFAULT_PART_NAME, name, open_mode, out_handle); } -extern "C" void nvs_close(nvs_handle handle) +extern "C" void nvs_close(nvs_handle_t handle) { Lock lock; ESP_LOGD(TAG, "%s %d", __func__, handle); @@ -313,7 +313,7 @@ extern "C" void nvs_close(nvs_handle handle) delete static_cast(it); } -extern "C" esp_err_t nvs_erase_key(nvs_handle handle, const char* key) +extern "C" esp_err_t nvs_erase_key(nvs_handle_t handle, const char* key) { Lock lock; ESP_LOGD(TAG, "%s %s\r\n", __func__, key); @@ -328,7 +328,7 @@ extern "C" esp_err_t nvs_erase_key(nvs_handle handle, const char* key) return entry.mStoragePtr->eraseItem(entry.mNsIndex, key); } -extern "C" esp_err_t nvs_erase_all(nvs_handle handle) +extern "C" esp_err_t nvs_erase_all(nvs_handle_t handle) { Lock lock; ESP_LOGD(TAG, "%s\r\n", __func__); @@ -344,7 +344,7 @@ extern "C" esp_err_t nvs_erase_all(nvs_handle handle) } template -static esp_err_t nvs_set(nvs_handle handle, const char* key, T value) +static esp_err_t nvs_set(nvs_handle_t handle, const char* key, T value) { Lock lock; ESP_LOGD(TAG, "%s %s %d %d", __func__, key, sizeof(T), (uint32_t) value); @@ -359,47 +359,47 @@ static esp_err_t nvs_set(nvs_handle handle, const char* key, T value) return entry.mStoragePtr->writeItem(entry.mNsIndex, key, value); } -extern "C" esp_err_t nvs_set_i8 (nvs_handle handle, const char* key, int8_t value) +extern "C" esp_err_t nvs_set_i8 (nvs_handle_t handle, const char* key, int8_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_set_u8 (nvs_handle handle, const char* key, uint8_t value) +extern "C" esp_err_t nvs_set_u8 (nvs_handle_t handle, const char* key, uint8_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_set_i16 (nvs_handle handle, const char* key, int16_t value) +extern "C" esp_err_t nvs_set_i16 (nvs_handle_t handle, const char* key, int16_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_set_u16 (nvs_handle handle, const char* key, uint16_t value) +extern "C" esp_err_t nvs_set_u16 (nvs_handle_t handle, const char* key, uint16_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_set_i32 (nvs_handle handle, const char* key, int32_t value) +extern "C" esp_err_t nvs_set_i32 (nvs_handle_t handle, const char* key, int32_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_set_u32 (nvs_handle handle, const char* key, uint32_t value) +extern "C" esp_err_t nvs_set_u32 (nvs_handle_t handle, const char* key, uint32_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_set_i64 (nvs_handle handle, const char* key, int64_t value) +extern "C" esp_err_t nvs_set_i64 (nvs_handle_t handle, const char* key, int64_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_set_u64 (nvs_handle handle, const char* key, uint64_t value) +extern "C" esp_err_t nvs_set_u64 (nvs_handle_t handle, const char* key, uint64_t value) { return nvs_set(handle, key, value); } -extern "C" esp_err_t nvs_commit(nvs_handle handle) +extern "C" esp_err_t nvs_commit(nvs_handle_t handle) { Lock lock; // no-op for now, to be used when intermediate cache is added @@ -407,7 +407,7 @@ extern "C" esp_err_t nvs_commit(nvs_handle handle) return nvs_find_ns_handle(handle, entry); } -extern "C" esp_err_t nvs_set_str(nvs_handle handle, const char* key, const char* value) +extern "C" esp_err_t nvs_set_str(nvs_handle_t handle, const char* key, const char* value) { Lock lock; ESP_LOGD(TAG, "%s %s %s", __func__, key, value); @@ -419,7 +419,7 @@ extern "C" esp_err_t nvs_set_str(nvs_handle handle, const char* key, const char* return entry.mStoragePtr->writeItem(entry.mNsIndex, nvs::ItemType::SZ, key, value, strlen(value) + 1); } -extern "C" esp_err_t nvs_set_blob(nvs_handle handle, const char* key, const void* value, size_t length) +extern "C" esp_err_t nvs_set_blob(nvs_handle_t handle, const char* key, const void* value, size_t length) { Lock lock; ESP_LOGD(TAG, "%s %s %d", __func__, key, length); @@ -433,7 +433,7 @@ extern "C" esp_err_t nvs_set_blob(nvs_handle handle, const char* key, const void template -static esp_err_t nvs_get(nvs_handle handle, const char* key, T* out_value) +static esp_err_t nvs_get(nvs_handle_t handle, const char* key, T* out_value) { Lock lock; ESP_LOGD(TAG, "%s %s %d", __func__, key, sizeof(T)); @@ -445,47 +445,47 @@ static esp_err_t nvs_get(nvs_handle handle, const char* key, T* out_value) return entry.mStoragePtr->readItem(entry.mNsIndex, key, *out_value); } -extern "C" esp_err_t nvs_get_i8 (nvs_handle handle, const char* key, int8_t* out_value) +extern "C" esp_err_t nvs_get_i8 (nvs_handle_t handle, const char* key, int8_t* out_value) { return nvs_get(handle, key, out_value); } -extern "C" esp_err_t nvs_get_u8 (nvs_handle handle, const char* key, uint8_t* out_value) +extern "C" esp_err_t nvs_get_u8 (nvs_handle_t handle, const char* key, uint8_t* out_value) { return nvs_get(handle, key, out_value); } -extern "C" esp_err_t nvs_get_i16 (nvs_handle handle, const char* key, int16_t* out_value) +extern "C" esp_err_t nvs_get_i16 (nvs_handle_t handle, const char* key, int16_t* out_value) { return nvs_get(handle, key, out_value); } -extern "C" esp_err_t nvs_get_u16 (nvs_handle handle, const char* key, uint16_t* out_value) +extern "C" esp_err_t nvs_get_u16 (nvs_handle_t handle, const char* key, uint16_t* out_value) { return nvs_get(handle, key, out_value); } -extern "C" esp_err_t nvs_get_i32 (nvs_handle handle, const char* key, int32_t* out_value) +extern "C" esp_err_t nvs_get_i32 (nvs_handle_t handle, const char* key, int32_t* out_value) { return nvs_get(handle, key, out_value); } -extern "C" esp_err_t nvs_get_u32 (nvs_handle handle, const char* key, uint32_t* out_value) +extern "C" esp_err_t nvs_get_u32 (nvs_handle_t handle, const char* key, uint32_t* out_value) { return nvs_get(handle, key, out_value); } -extern "C" esp_err_t nvs_get_i64 (nvs_handle handle, const char* key, int64_t* out_value) +extern "C" esp_err_t nvs_get_i64 (nvs_handle_t handle, const char* key, int64_t* out_value) { return nvs_get(handle, key, out_value); } -extern "C" esp_err_t nvs_get_u64 (nvs_handle handle, const char* key, uint64_t* out_value) +extern "C" esp_err_t nvs_get_u64 (nvs_handle_t handle, const char* key, uint64_t* out_value) { return nvs_get(handle, key, out_value); } -static esp_err_t nvs_get_str_or_blob(nvs_handle handle, nvs::ItemType type, const char* key, void* out_value, size_t* length) +static esp_err_t nvs_get_str_or_blob(nvs_handle_t handle, nvs::ItemType type, const char* key, void* out_value, size_t* length) { Lock lock; ESP_LOGD(TAG, "%s %s", __func__, key); @@ -515,12 +515,12 @@ static esp_err_t nvs_get_str_or_blob(nvs_handle handle, nvs::ItemType type, cons return entry.mStoragePtr->readItem(entry.mNsIndex, type, key, out_value, dataSize); } -extern "C" esp_err_t nvs_get_str(nvs_handle handle, const char* key, char* out_value, size_t* length) +extern "C" esp_err_t nvs_get_str(nvs_handle_t handle, const char* key, char* out_value, size_t* length) { return nvs_get_str_or_blob(handle, nvs::ItemType::SZ, key, out_value, length); } -extern "C" esp_err_t nvs_get_blob(nvs_handle handle, const char* key, void* out_value, size_t* length) +extern "C" esp_err_t nvs_get_blob(nvs_handle_t handle, const char* key, void* out_value, size_t* length) { return nvs_get_str_or_blob(handle, nvs::ItemType::BLOB, key, out_value, length); } @@ -550,7 +550,7 @@ extern "C" esp_err_t nvs_get_stats(const char* part_name, nvs_stats_t* nvs_stats return pStorage->fillStats(*nvs_stats); } -extern "C" esp_err_t nvs_get_used_entry_count(nvs_handle handle, size_t* used_entries) +extern "C" esp_err_t nvs_get_used_entry_count(nvs_handle_t handle, size_t* used_entries) { Lock lock; if(used_entries == NULL){ diff --git a/components/nvs_flash/test/test_nvs.c b/components/nvs_flash/test/test_nvs.c index a8667dc01..0c86f4756 100644 --- a/components/nvs_flash/test/test_nvs.c +++ b/components/nvs_flash/test/test_nvs.c @@ -20,7 +20,7 @@ static const char* TAG = "test_nvs"; TEST_CASE("various nvs tests", "[nvs]") { - nvs_handle handle_1; + nvs_handle_t handle_1; esp_err_t err = nvs_flash_init(); if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) { ESP_LOGW(TAG, "nvs_flash_init failed (0x%x), erasing partition and retrying", err); @@ -42,7 +42,7 @@ TEST_CASE("various nvs tests", "[nvs]") TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x12345678)); TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x23456789)); - nvs_handle handle_2; + nvs_handle_t handle_2; TEST_ESP_OK(nvs_open("test_namespace3", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_erase_all(handle_2)); TEST_ESP_OK(nvs_set_i32(handle_2, "foo", 0x3456789a)); @@ -83,7 +83,7 @@ TEST_CASE("calculate used and free space", "[nvs]") TEST_ASSERT_TRUE(stat1.total_entries == 0); TEST_ASSERT_TRUE(stat1.used_entries == 0); - nvs_handle handle = 0; + nvs_handle_t handle = 0; size_t h_count_entries; TEST_ESP_ERR(nvs_get_used_entry_count(handle, &h_count_entries), ESP_ERR_NVS_INVALID_HANDLE); TEST_ASSERT_TRUE(h_count_entries == 0); @@ -115,7 +115,7 @@ TEST_CASE("calculate used and free space", "[nvs]") TEST_ASSERT_TRUE(stat1.used_entries == 0); // create namespace test_k1 - nvs_handle handle_1; + nvs_handle_t handle_1; TEST_ESP_OK(nvs_open("test_k1", NVS_READWRITE, &handle_1)); TEST_ESP_OK(nvs_get_stats(NULL, &stat2)); TEST_ASSERT_TRUE(stat2.free_entries + 1 == stat1.free_entries); @@ -152,7 +152,7 @@ TEST_CASE("calculate used and free space", "[nvs]") TEST_ESP_OK(nvs_get_used_entry_count(handle_1, &h1_count_entries)); TEST_ASSERT_TRUE(h1_count_entries == 2); - nvs_handle handle_2; + nvs_handle_t handle_2; // create namespace test_k2 TEST_ESP_OK(nvs_open("test_k2", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_get_stats(NULL, &stat2)); @@ -189,7 +189,7 @@ TEST_CASE("calculate used and free space", "[nvs]") h2_count_entries = temp; TEST_ESP_ERR(nvs_get_used_entry_count(handle_1, NULL), ESP_ERR_INVALID_ARG); - nvs_handle handle_3; + nvs_handle_t handle_3; // create namespace test_k3 TEST_ESP_OK(nvs_open("test_k3", NVS_READWRITE, &handle_3)); TEST_ESP_OK(nvs_get_stats(NULL, &stat2)); @@ -230,7 +230,7 @@ TEST_CASE("check for memory leaks in nvs_set_blob", "[nvs]") TEST_ESP_OK( err ); for (int i = 0; i < 500; ++i) { - nvs_handle my_handle; + nvs_handle_t my_handle; uint8_t key[20] = {0}; TEST_ESP_OK( nvs_open("test_namespace1", NVS_READWRITE, &my_handle) ); @@ -346,7 +346,7 @@ TEST_CASE("test nvs apis with encryption enabled", "[nvs]") } TEST_ESP_OK(nvs_flash_secure_init(&cfg)); - nvs_handle handle_1; + nvs_handle_t handle_1; TEST_ESP_ERR(nvs_open("namespace1", NVS_READONLY, &handle_1), ESP_ERR_NVS_NOT_FOUND); @@ -356,7 +356,7 @@ TEST_CASE("test nvs apis with encryption enabled", "[nvs]") TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x12345678)); TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x23456789)); - nvs_handle handle_2; + nvs_handle_t handle_2; TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_set_i32(handle_2, "foo", 0x3456789a)); const char* str = "value 0123456789abcdef0123456789abcdef"; @@ -403,7 +403,7 @@ TEST_CASE("test nvs apis for nvs partition generator utility with encryption ena TEST_IGNORE_MESSAGE("flash encryption disabled, skipping nvs_api tests with encryption enabled"); } - nvs_handle handle; + nvs_handle_t handle; nvs_sec_cfg_t xts_cfg; extern const char nvs_key_start[] asm("_binary_encryption_keys_bin_start"); diff --git a/components/nvs_flash/test_nvs_host/test_nvs.cpp b/components/nvs_flash/test_nvs_host/test_nvs.cpp index 126b1bc28..3cfa2b0e4 100644 --- a/components/nvs_flash/test_nvs_host/test_nvs.cpp +++ b/components/nvs_flash/test_nvs_host/test_nvs.cpp @@ -552,7 +552,7 @@ TEST_CASE("nvs api tests", "[nvs]") SpiFlashEmulator emu(10); emu.randomize(100); - nvs_handle handle_1; + nvs_handle_t handle_1; const uint32_t NVS_FLASH_SECTOR = 6; const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3; emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN); @@ -573,7 +573,7 @@ TEST_CASE("nvs api tests", "[nvs]") TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x12345678)); TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x23456789)); - nvs_handle handle_2; + nvs_handle_t handle_2; TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_set_i32(handle_2, "foo", 0x3456789a)); const char* str = "value 0123456789abcdef0123456789abcdef"; @@ -620,7 +620,7 @@ TEST_CASE("wifi test", "[nvs]") emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN); TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN)); - nvs_handle misc_handle; + nvs_handle_t misc_handle; TEST_ESP_OK(nvs_open("nvs.net80211", NVS_READWRITE, &misc_handle)); char log[33]; size_t log_size = sizeof(log); @@ -628,7 +628,7 @@ TEST_CASE("wifi test", "[nvs]") strcpy(log, "foobarbazfizzz"); TEST_ESP_OK(nvs_set_str(misc_handle, "log", log)); - nvs_handle net80211_handle; + nvs_handle_t net80211_handle; TEST_ESP_OK(nvs_open("nvs.net80211", NVS_READWRITE, &net80211_handle)); uint8_t opmode = 2; @@ -808,7 +808,7 @@ TEST_CASE("can init storage from flash with random contents", "[nvs]") SpiFlashEmulator emu(10); emu.randomize(42); - nvs_handle handle; + nvs_handle_t handle; const uint32_t NVS_FLASH_SECTOR = 5; const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3; emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN); @@ -842,13 +842,13 @@ TEST_CASE("nvs api tests, starting with random data in flash", "[nvs][long]") TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN)); - nvs_handle handle_1; + nvs_handle_t handle_1; TEST_ESP_ERR(nvs_open("namespace1", NVS_READONLY, &handle_1), ESP_ERR_NVS_NOT_FOUND); TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle_1)); TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x12345678)); for (size_t i = 0; i < 500; ++i) { - nvs_handle handle_2; + nvs_handle_t handle_2; TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x23456789 % (i + 1))); TEST_ESP_OK(nvs_set_i32(handle_2, "foo", static_cast(i))); @@ -897,7 +897,7 @@ public: } template - esp_err_t doRandomThings(nvs_handle handle, TGen gen, size_t& count) { + esp_err_t doRandomThings(nvs_handle_t handle, TGen gen, size_t& count) { const char* keys[] = {"foo", "bar", "longkey_0123456", "another key", "param1", "param2", "param3", "param4", "param5", "singlepage", "multipage"}; const ItemType types[] = {ItemType::I32, ItemType::I32, ItemType::U64, ItemType::U64, ItemType::SZ, ItemType::SZ, ItemType::SZ, ItemType::SZ, ItemType::SZ, ItemType::BLOB, ItemType::BLOB}; @@ -1150,7 +1150,7 @@ TEST_CASE("monkey test", "[nvs][monkey]") TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN)); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle)); RandomTest test; size_t count = 1000; @@ -1192,7 +1192,7 @@ TEST_CASE("test recovery from sudden poweroff", "[long][nvs][recovery][monkey]") } - nvs_handle handle; + nvs_handle_t handle; size_t count = iter_count; if (nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN) == ESP_OK) { @@ -1225,7 +1225,7 @@ TEST_CASE("test for memory leaks in open/set", "[leaks]") TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN)); for (int i = 0; i < 100000; ++i) { - nvs_handle light_handle = 0; + nvs_handle_t light_handle = 0; char lightbulb[1024] = {12, 13, 14, 15, 16}; TEST_ESP_OK(nvs_open("light", NVS_READWRITE, &light_handle)); TEST_ESP_OK(nvs_set_blob(light_handle, "key", lightbulb, sizeof(lightbulb))); @@ -1380,7 +1380,7 @@ TEST_CASE("read/write failure (TW8406)", "[nvs]") nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 3); for (int attempts = 0; attempts < 3; ++attempts) { int i = 0; - nvs_handle light_handle = 0; + nvs_handle_t light_handle = 0; char key[15] = {0}; char data[76] = {12, 13, 14, 15, 16}; uint8_t number = 20; @@ -1412,7 +1412,7 @@ TEST_CASE("nvs_flash_init checks for an empty page", "[nvs]") uint8_t blob[blob_size] = {0}; SpiFlashEmulator emu(5); TEST_ESP_OK( nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 5) ); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK( nvs_open("test", NVS_READWRITE, &handle) ); // Fill first page TEST_ESP_OK( nvs_set_blob(handle, "1a", blob, blob_size) ); @@ -1432,7 +1432,7 @@ TEST_CASE("multiple partitions access check", "[nvs]") SpiFlashEmulator emu(10); TEST_ESP_OK( nvs_flash_init_custom("nvs1", 0, 5) ); TEST_ESP_OK( nvs_flash_init_custom("nvs2", 5, 5) ); - nvs_handle handle1, handle2; + nvs_handle_t handle1, handle2; TEST_ESP_OK( nvs_open_from_partition("nvs1", "test", NVS_READWRITE, &handle1) ); TEST_ESP_OK( nvs_open_from_partition("nvs2", "test", NVS_READWRITE, &handle2) ); TEST_ESP_OK( nvs_set_i32(handle1, "foo", 0xdeadbeef)); @@ -1450,7 +1450,7 @@ TEST_CASE("nvs page selection takes into account free entries also not just eras uint8_t blob[blob_size] = {0}; SpiFlashEmulator emu(3); TEST_ESP_OK( nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 3) ); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK( nvs_open("test", NVS_READWRITE, &handle) ); // Fill first page TEST_ESP_OK( nvs_set_blob(handle, "1a", blob, blob_size/3) ); @@ -1478,7 +1478,7 @@ TEST_CASE("calculate used and free space", "[nvs]") CHECK(stat1.total_entries == 0); CHECK(stat1.used_entries == 0); - nvs_handle handle = 0; + nvs_handle_t handle = 0; size_t h_count_entries; TEST_ESP_ERR(nvs_get_used_entry_count(handle, &h_count_entries), ESP_ERR_NVS_INVALID_HANDLE); CHECK(h_count_entries == 0); @@ -1498,7 +1498,7 @@ TEST_CASE("calculate used and free space", "[nvs]") CHECK(stat1.used_entries == 0); // create namespace test_k1 - nvs_handle handle_1; + nvs_handle_t handle_1; TEST_ESP_OK(nvs_open("test_k1", NVS_READWRITE, &handle_1)); TEST_ESP_OK(nvs_get_stats(NULL, &stat2)); CHECK(stat2.free_entries + 1 == stat1.free_entries); @@ -1535,7 +1535,7 @@ TEST_CASE("calculate used and free space", "[nvs]") TEST_ESP_OK(nvs_get_used_entry_count(handle_1, &h1_count_entries)); CHECK(h1_count_entries == 2); - nvs_handle handle_2; + nvs_handle_t handle_2; // create namespace test_k2 TEST_ESP_OK(nvs_open("test_k2", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_get_stats(NULL, &stat2)); @@ -1572,7 +1572,7 @@ TEST_CASE("calculate used and free space", "[nvs]") h2_count_entries = temp; TEST_ESP_ERR(nvs_get_used_entry_count(handle_1, NULL), ESP_ERR_INVALID_ARG); - nvs_handle handle_3; + nvs_handle_t handle_3; // create namespace test_k3 TEST_ESP_OK(nvs_open("test_k3", NVS_READWRITE, &handle_3)); TEST_ESP_OK(nvs_get_stats(NULL, &stat2)); @@ -1607,7 +1607,7 @@ TEST_CASE("Recovery from power-off when the entry being erased is not on active uint8_t blob[blob_size] = {0x11}; SpiFlashEmulator emu(3); TEST_ESP_OK( nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 3) ); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK( nvs_open("test", NVS_READWRITE, &handle) ); emu.clearStats(); @@ -1635,7 +1635,7 @@ TEST_CASE("Recovery from power-off when page is being freed.", "[nvs]") uint8_t blob[blob_size] = {0}; SpiFlashEmulator emu(3); TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 3)); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("test", NVS_READWRITE, &handle)); // Fill first page TEST_ESP_OK(nvs_set_blob(handle, "1a", blob, blob_size/3)); @@ -1675,7 +1675,7 @@ TEST_CASE("Multi-page blobs are supported", "[nvs]") uint8_t blob[blob_size] = {0}; SpiFlashEmulator emu(5); TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 5)); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("test", NVS_READWRITE, &handle)); TEST_ESP_OK(nvs_set_blob(handle, "abc", blob, blob_size)); TEST_ESP_OK(nvs_commit(handle)); @@ -1688,7 +1688,7 @@ TEST_CASE("Failures are handled while storing multi-page blobs", "[nvs]") uint8_t blob[blob_size] = {0}; SpiFlashEmulator emu(5); TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 5)); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("test", NVS_READWRITE, &handle)); TEST_ESP_ERR(nvs_set_blob(handle, "abc", blob, blob_size), ESP_ERR_NVS_VALUE_TOO_LONG); TEST_ESP_OK(nvs_set_blob(handle, "abc", blob, Page::CHUNK_MAX_SIZE*2)); @@ -1704,7 +1704,7 @@ TEST_CASE("Reading multi-page blobs", "[nvs]") size_t read_size = blob_size; SpiFlashEmulator emu(5); TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 5)); - nvs_handle handle; + nvs_handle_t handle; memset(blob, 0x11, blob_size); memset(blob_read, 0xee, blob_size); TEST_ESP_OK(nvs_open("readTest", NVS_READWRITE, &handle)); @@ -1726,7 +1726,7 @@ TEST_CASE("Modification of values for Multi-page blobs are supported", "[nvs]") size_t read_size = blob_size; SpiFlashEmulator emu(6); TEST_ESP_OK( nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 6) ); - nvs_handle handle; + nvs_handle_t handle; memset(blob, 0x11, blob_size); memset(blob2, 0x22, blob_size); memset(blob3, 0x33, blob_size); @@ -1751,7 +1751,7 @@ TEST_CASE("Modification from single page blob to multi-page", "[nvs]") size_t read_size = blob_size; SpiFlashEmulator emu(5); TEST_ESP_OK( nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 5) ); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("Test", NVS_READWRITE, &handle) ); TEST_ESP_OK(nvs_set_blob(handle, "abc", blob, Page::CHUNK_MAX_SIZE/2)); TEST_ESP_OK(nvs_set_blob(handle, "abc", blob, blob_size)); @@ -1769,7 +1769,7 @@ TEST_CASE("Modification from multi-page to single page", "[nvs]") size_t read_size = blob_size; SpiFlashEmulator emu(5); TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 5) ); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("Test", NVS_READWRITE, &handle) ); TEST_ESP_OK(nvs_set_blob(handle, "abc", blob, blob_size)); TEST_ESP_OK(nvs_set_blob(handle, "abc", blob, Page::CHUNK_MAX_SIZE/2)); @@ -1836,7 +1836,7 @@ TEST_CASE("nvs blob fragmentation test", "[nvs]") CHECK(blob != NULL); memset(blob, 0xEE, BLOB_SIZE); const uint32_t magic = 0xff33eaeb; - nvs_handle h; + nvs_handle_t h; TEST_ESP_OK( nvs_open("blob_tests", NVS_READWRITE, &h) ); for (int i = 0; i < 128; i++) { INFO("Iteration " << i << "...\n"); @@ -1887,7 +1887,7 @@ TEST_CASE("Check for nvs version incompatibility", "[nvs]") TEST_CASE("Check that NVS supports old blob format without blob index", "[nvs]") { SpiFlashEmulator emu("../nvs_partition_generator/part_old_blob_format.bin"); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK( nvs_flash_init_custom("test", 0, 2) ); TEST_ESP_OK( nvs_open_from_partition("test", "dummyNamespace", NVS_READONLY, &handle)); @@ -1948,7 +1948,7 @@ TEST_CASE("monkey test with old-format blob present", "[nvs][monkey]") TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN)); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle)); RandomTest test; @@ -2031,7 +2031,7 @@ TEST_CASE("Recovery from power-off during modification of blob present in old-fo TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 3)); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle)); uint8_t hexdata[] = {0x01, 0x02, 0x03, 0xab, 0xcd, 0xef}; @@ -2083,7 +2083,7 @@ TEST_CASE("Recovery from power-off during modification of blob present in old-fo TEST_ESP_OK(nvs_flash_init_custom(NVS_DEFAULT_PART_NAME, 0, 3)); - nvs_handle handle; + nvs_handle_t handle; TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle)); uint8_t hexdata[] = {0x01, 0x02, 0x03, 0xab, 0xcd, 0xef}; @@ -2129,7 +2129,7 @@ TEST_CASE("Recovery from power-off during modification of blob present in old-fo static void check_nvs_part_gen_args(char const *part_name, int size, char const *filename, bool is_encr, nvs_sec_cfg_t* xts_cfg) { - nvs_handle handle; + nvs_handle_t handle; if (is_encr) TEST_ESP_OK(nvs_flash_secure_init_custom(part_name, 0, size, xts_cfg)); @@ -2547,7 +2547,7 @@ TEST_CASE("test nvs apis with encryption enabled", "[nvs]") SpiFlashEmulator emu(10); emu.randomize(100); - nvs_handle handle_1; + nvs_handle_t handle_1; const uint32_t NVS_FLASH_SECTOR = 6; const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3; emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN); @@ -2570,7 +2570,7 @@ TEST_CASE("test nvs apis with encryption enabled", "[nvs]") TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x12345678)); TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x23456789)); - nvs_handle handle_2; + nvs_handle_t handle_2; TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_set_i32(handle_2, "foo", 0x3456789a)); const char* str = "value 0123456789abcdef0123456789abcdef"; diff --git a/examples/storage/nvs_rw_blob/main/nvs_blob_example_main.c b/examples/storage/nvs_rw_blob/main/nvs_blob_example_main.c index 410ced3f0..f6b74766e 100644 --- a/examples/storage/nvs_rw_blob/main/nvs_blob_example_main.c +++ b/examples/storage/nvs_rw_blob/main/nvs_blob_example_main.c @@ -27,7 +27,7 @@ */ esp_err_t save_restart_counter(void) { - nvs_handle my_handle; + nvs_handle_t my_handle; esp_err_t err; // Open @@ -64,7 +64,7 @@ esp_err_t save_restart_counter(void) */ esp_err_t save_run_time(void) { - nvs_handle my_handle; + nvs_handle_t my_handle; esp_err_t err; // Open @@ -110,7 +110,7 @@ esp_err_t save_run_time(void) */ esp_err_t print_what_saved(void) { - nvs_handle my_handle; + nvs_handle_t my_handle; esp_err_t err; // Open diff --git a/examples/storage/nvs_rw_value/main/nvs_value_example_main.c b/examples/storage/nvs_rw_value/main/nvs_value_example_main.c index cd03269f0..757eeeb30 100644 --- a/examples/storage/nvs_rw_value/main/nvs_value_example_main.c +++ b/examples/storage/nvs_rw_value/main/nvs_value_example_main.c @@ -31,7 +31,7 @@ void app_main() // Open printf("\n"); printf("Opening Non-Volatile Storage (NVS) handle... "); - nvs_handle my_handle; + nvs_handle_t my_handle; err = nvs_open("storage", NVS_READWRITE, &my_handle); if (err != ESP_OK) { printf("Error (%s) opening NVS handle!\n", esp_err_to_name(err)); diff --git a/examples/system/console/components/cmd_nvs/cmd_nvs.c b/examples/system/console/components/cmd_nvs/cmd_nvs.c index c075496ca..50fb11e29 100644 --- a/examples/system/console/components/cmd_nvs/cmd_nvs.c +++ b/examples/system/console/components/cmd_nvs/cmd_nvs.c @@ -86,7 +86,7 @@ static nvs_type_t str_to_type(const char *type) return NVS_TYPE_ANY; } -static esp_err_t store_blob(nvs_handle nvs, const char *key, const char *str_values) +static esp_err_t store_blob(nvs_handle_t nvs, const char *key, const char *str_values) { uint8_t value; size_t str_len = strlen(str_values); @@ -144,7 +144,7 @@ static void print_blob(const char *blob, size_t len) static esp_err_t set_value_in_nvs(const char *key, const char *str_type, const char *str_value) { esp_err_t err; - nvs_handle nvs; + nvs_handle_t nvs; bool range_error = false; nvs_type_t type = str_to_type(str_type); @@ -230,7 +230,7 @@ static esp_err_t set_value_in_nvs(const char *key, const char *str_type, const c static esp_err_t get_value_from_nvs(const char *key, const char *str_type) { - nvs_handle nvs; + nvs_handle_t nvs; esp_err_t err; nvs_type_t type = str_to_type(str_type); @@ -314,7 +314,7 @@ static esp_err_t get_value_from_nvs(const char *key, const char *str_type) static esp_err_t erase(const char *key) { - nvs_handle nvs; + nvs_handle_t nvs; esp_err_t err = nvs_open(current_namespace, NVS_READWRITE, &nvs); if (err == ESP_OK) { @@ -333,7 +333,7 @@ static esp_err_t erase(const char *key) static esp_err_t erase_all(const char *name) { - nvs_handle nvs; + nvs_handle_t nvs; esp_err_t err = nvs_open(current_namespace, NVS_READWRITE, &nvs); if (err == ESP_OK) { diff --git a/examples/system/ulp/main/ulp_example_main.c b/examples/system/ulp/main/ulp_example_main.c index a6e76bacb..6682294d5 100644 --- a/examples/system/ulp/main/ulp_example_main.c +++ b/examples/system/ulp/main/ulp_example_main.c @@ -97,7 +97,7 @@ static void update_pulse_count() const char* count_key = "count"; ESP_ERROR_CHECK( nvs_flash_init() ); - nvs_handle handle; + nvs_handle_t handle; ESP_ERROR_CHECK( nvs_open(namespace, NVS_READWRITE, &handle)); uint32_t pulse_count = 0; esp_err_t err = nvs_get_u32(handle, count_key, &pulse_count); From b2e54a9cc644668a766eaebd2e2819419145ac89 Mon Sep 17 00:00:00 2001 From: Angus Gratton Date: Wed, 17 Apr 2019 16:31:07 +1000 Subject: [PATCH 2/2] ci: Add IDF_DEPRECATED macro for things we only deprecate in our CI passes --- components/esp32/include/esp_attr.h | 9 +++++++++ components/nvs_flash/include/nvs.h | 5 +++-- docs/Doxyfile | 1 + tools/ci/configure_ci_environment.sh | 2 +- 4 files changed, 14 insertions(+), 3 deletions(-) diff --git a/components/esp32/include/esp_attr.h b/components/esp32/include/esp_attr.h index c9e3879ee..7a3ec771d 100644 --- a/components/esp32/include/esp_attr.h +++ b/components/esp32/include/esp_attr.h @@ -84,4 +84,13 @@ #define _COUNTER_STRINGIFY(COUNTER) #COUNTER +/* Use IDF_DEPRECATED attribute to mark anything deprecated from use in + ESP-IDF's own source code, but not deprecated for external users. +*/ +#ifdef IDF_CI_BUILD +#define IDF_DEPRECATED(REASON) __attribute__((deprecated(REASON))) +#else +#define IDF_DEPRECATED(REASON) +#endif + #endif /* __ESP_ATTR_H__ */ diff --git a/components/nvs_flash/include/nvs.h b/components/nvs_flash/include/nvs.h index 13f5b9552..f30ffd03a 100644 --- a/components/nvs_flash/include/nvs.h +++ b/components/nvs_flash/include/nvs.h @@ -17,6 +17,7 @@ #include #include #include +#include "esp_attr.h" #include "esp_err.h" #ifdef __cplusplus @@ -31,7 +32,7 @@ typedef uint32_t nvs_handle_t; /* * Pre-IDF V4.0 uses nvs_handle, so leaving the original typedef here for compatibility. */ -typedef nvs_handle_t nvs_handle; +typedef nvs_handle_t nvs_handle IDF_DEPRECATED("Replace with nvs_handle_t"); #define ESP_ERR_NVS_BASE 0x1100 /*!< Starting number of error codes */ #define ESP_ERR_NVS_NOT_INITIALIZED (ESP_ERR_NVS_BASE + 0x01) /*!< The storage driver is not initialized */ @@ -74,7 +75,7 @@ typedef enum { /* * Pre-IDF V4.0 uses nvs_open_mode, so leaving the original typedef here for compatibility. */ -typedef nvs_open_mode_t nvs_open_mode +typedef nvs_open_mode_t nvs_open_mode IDF_DEPRECATED("Replace with nvs_open_mode_t"); typedef enum { NVS_TYPE_U8 = 0x01, diff --git a/docs/Doxyfile b/docs/Doxyfile index cd92c6909..c48ca6211 100644 --- a/docs/Doxyfile +++ b/docs/Doxyfile @@ -232,6 +232,7 @@ MACRO_EXPANSION = YES EXPAND_ONLY_PREDEF = YES PREDEFINED = \ __attribute__(x)= \ + IDF_DEPRECATED(X)= \ IRAM_ATTR= \ configSUPPORT_DYNAMIC_ALLOCATION=1 \ configSUPPORT_STATIC_ALLOCATION=1 \ diff --git a/tools/ci/configure_ci_environment.sh b/tools/ci/configure_ci_environment.sh index 1d4380ad5..73721746e 100644 --- a/tools/ci/configure_ci_environment.sh +++ b/tools/ci/configure_ci_environment.sh @@ -33,4 +33,4 @@ unset REF # Compiler flags to thoroughly check the IDF code in some CI jobs # (Depends on default options '-Wno-error=XXX' used in the IDF build system) -export PEDANTIC_CFLAGS="-Werror -Werror=deprecated-declarations -Werror=unused-variable -Werror=unused-but-set-variable -Werror=unused-function" +export PEDANTIC_CFLAGS="-DIDF_CI_BUILD -Werror -Werror=deprecated-declarations -Werror=unused-variable -Werror=unused-but-set-variable -Werror=unused-function"