From 4e82e94d5bb825b1ca1d8511f5f9ce8939dee165 Mon Sep 17 00:00:00 2001 From: brand Date: Mon, 28 Oct 2019 11:10:00 +0800 Subject: [PATCH 1/4] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E8=BF=AD=E4=BB=A3?= =?UTF-8?q?=E5=99=A8=20env=5Fiterator=5Fto=5Ffirst();=E8=BF=AD=E4=BB=A3?= =?UTF-8?q?=E5=99=A8=E4=BB=8E=E5=A4=B4=E5=BC=80=E5=A7=8B=E9=81=8D=E5=8E=86?= =?UTF-8?q?=20env=5Fiterator=5Fnext(char=20*key,void=20*value=5Fbuf,=20siz?= =?UTF-8?q?e=5Ft=20*value=5Flen);=E8=8E=B7=E5=8F=96=E4=B8=8B=E4=B8=80?= =?UTF-8?q?=E4=B8=AA=E7=8E=AF=E5=A2=83=E5=8F=98=E9=87=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- easyflash/inc/easyflash.h | 2 + easyflash/src/ef_env.c | 79 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 81 insertions(+) diff --git a/easyflash/inc/easyflash.h b/easyflash/inc/easyflash.h index 5d109ea..b8d0932 100644 --- a/easyflash/inc/easyflash.h +++ b/easyflash/inc/easyflash.h @@ -112,6 +112,8 @@ EfErrCode ef_env_set_default(void); size_t ef_get_env_write_bytes(void); EfErrCode ef_set_and_save_env(const char *key, const char *value); EfErrCode ef_del_and_save_env(const char *key); +void env_iterator_to_first(); +char env_iterator_next(char *key, void *value_buf, size_t *value_len); #endif #ifdef EF_USING_IAP diff --git a/easyflash/src/ef_env.c b/easyflash/src/ef_env.c index fadfd16..dd3ab00 100644 --- a/easyflash/src/ef_env.c +++ b/easyflash/src/ef_env.c @@ -215,6 +215,13 @@ struct env_meta_data { }; typedef struct env_meta_data *env_meta_data_t; +struct env_iterator_obj +{ + struct sector_meta_data sector; + struct env_meta_data env; +}; +typedef struct env_iterator_obj *env_iterator_obj_t; + struct env_cache_node { uint16_t name_crc; /**< ENV name's CRC32 low 16bit value */ uint16_t active; /**< ENV node access active degree */ @@ -1159,7 +1166,79 @@ __retry: return empty_env; } +static struct env_iterator_obj obj; +/** + * @brief Traversing from scratch + * + */ +void env_iterator_to_first() +{ + obj.sector.addr = FAILED_ADDR; + obj.env.addr.start = FAILED_ADDR; +} + +/** + * @brief Get next blob ENV + * + * @param key ENV name buffer + * @param value_buf ENV blob buffer + * @param value_len ENV blob buffer length + * @return char 1:Traversal complete 0:Traversal not complete + */ +char env_iterator_next(char *key, void *value_buf, size_t *value_len) +{ + uint32_t sec_addr; + ef_port_env_lock(); + if (obj.sector.addr == FAILED_ADDR) + { +_reload: + if ((sec_addr = get_next_sector_addr(&obj.sector)) == FAILED_ADDR) + { + ef_port_env_unlock(); + return 1; + } + if (read_sector_meta_data(sec_addr, &obj.sector, false) != EF_NO_ERR) + { + goto _reload; + } + } + + if (obj.sector.status.store == SECTOR_STORE_USING || obj.sector.status.store == SECTOR_STORE_FULL) + { + /* search all ENV */ +_next: + if ((obj.env.addr.start = get_next_env_addr(&obj.sector, &obj.env)) != FAILED_ADDR) + { + read_env(&obj.env); + /* iterator is interrupted when callback return true */ + if (obj.env.status == ENV_WRITE) + { + //key = obj.env.name; + memcpy(key, obj.env.name, obj.env.name_len); + key[obj.env.name_len] = 0; + *value_len = obj.env.value_len; + ef_port_read(obj.env.addr.value, (uint32_t *) value_buf, *value_len); + + ef_port_env_unlock(); + return 0; + } + else + { + goto _next; + } + + } + else + { + goto _reload; + } + } + else + { + goto _reload; + } +} static uint32_t new_env_by_kv(sector_meta_data_t sector, size_t key_len, size_t buf_len) { size_t env_len = ENV_HDR_DATA_SIZE + EF_WG_ALIGN(key_len) + EF_WG_ALIGN(buf_len); From c401ae113908320a47c9f829755304d5ca5885f9 Mon Sep 17 00:00:00 2001 From: brand Date: Wed, 20 Nov 2019 15:34:34 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E8=BF=AD=E4=BB=A3?= =?UTF-8?q?=E5=99=A8=E4=BD=BF=E7=94=A8=E6=96=B9=E6=B3=95=20=E8=B0=83?= =?UTF-8?q?=E7=94=A8ef=5Fenv=5Fiterator=5Fto=5Ffirst()=E5=B0=86=E8=BF=AD?= =?UTF-8?q?=E4=BB=A3=E5=99=A8=E6=8C=87=E5=90=91=E6=9C=80=E5=BC=80=E5=A7=8B?= =?UTF-8?q?=20=E8=B0=83=E7=94=A8ef=5Fenv=5Fiterator=5Fnext()=E5=B0=86?= =?UTF-8?q?=E8=BF=AD=E4=BB=A3=E5=99=A8=E6=8C=87=E5=90=91=E4=B8=8B=E4=B8=80?= =?UTF-8?q?=E4=B8=AA=E5=8F=98=E9=87=8F=20=E8=B0=83=E7=94=A8ef=5Fenv=5Fiter?= =?UTF-8?q?ator=5Fnow=5Fname()=E8=8E=B7=E5=8F=96=E8=BF=AD=E4=BB=A3?= =?UTF-8?q?=E5=99=A8=E5=BD=93=E5=89=8D=E6=8C=87=E5=90=91=E7=9A=84=E5=8F=98?= =?UTF-8?q?=E9=87=8F=E7=9A=84=E5=90=8D=E5=AD=97=20=E8=B0=83=E7=94=A8ef=5Fe?= =?UTF-8?q?nv=5Fiterator=5Fnow=5Fvalue=5Flen()=E8=8E=B7=E5=8F=96=E8=BF=AD?= =?UTF-8?q?=E4=BB=A3=E5=99=A8=E5=BD=93=E5=89=8D=E6=8C=87=E5=90=91=E7=9A=84?= =?UTF-8?q?=E5=8F=98=E9=87=8F=E7=9A=84=E6=95=B0=E6=8D=AE=E9=95=BF=E5=BA=A6?= =?UTF-8?q?=20=E8=B0=83=E7=94=A8ef=5Fenv=5Fiterator=5Fnow=5Fvalue()?= =?UTF-8?q?=E8=8E=B7=E5=8F=96=E8=BF=AD=E4=BB=A3=E5=99=A8=E5=BD=93=E5=89=8D?= =?UTF-8?q?=E6=8C=87=E5=90=91=E7=9A=84=E5=8F=98=E9=87=8F=E7=9A=84=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=20=E6=B3=A8=E6=84=8F=E8=B0=83=E7=94=A8ef=5Fenv=5Fiter?= =?UTF-8?q?ator=5Fto=5Ffirst()=E4=B9=8B=E5=90=8E=E8=A6=81=E5=86=8D?= =?UTF-8?q?=E8=B0=83=E7=94=A8ef=5Fenv=5Fiterator=5Fnext()=E6=89=8D?= =?UTF-8?q?=E8=83=BD=E8=8E=B7=E5=8F=96=E7=AC=AC=E4=B8=80=E4=B8=AA=E5=85=83?= =?UTF-8?q?=E7=B4=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- easyflash/inc/easyflash.h | 8 +++-- easyflash/src/ef_env.c | 75 +++++++++++++++++++++++++++------------ 2 files changed, 59 insertions(+), 24 deletions(-) diff --git a/easyflash/inc/easyflash.h b/easyflash/inc/easyflash.h index b8d0932..d88aab5 100644 --- a/easyflash/inc/easyflash.h +++ b/easyflash/inc/easyflash.h @@ -112,8 +112,12 @@ EfErrCode ef_env_set_default(void); size_t ef_get_env_write_bytes(void); EfErrCode ef_set_and_save_env(const char *key, const char *value); EfErrCode ef_del_and_save_env(const char *key); -void env_iterator_to_first(); -char env_iterator_next(char *key, void *value_buf, size_t *value_len); +/* iterator*/ +void ef_env_iterator_to_first(void); +char *ef_env_iterator_now_name(void); +size_t ef_env_iterator_now_value_len(void); +size_t ef_env_iterator_now_value(void *value_buf, size_t buf_len); +char ef_env_iterator_next(void); #endif #ifdef EF_USING_IAP diff --git a/easyflash/src/ef_env.c b/easyflash/src/ef_env.c index dd3ab00..680ea88 100644 --- a/easyflash/src/ef_env.c +++ b/easyflash/src/ef_env.c @@ -1166,17 +1166,56 @@ __retry: return empty_env; } -static struct env_iterator_obj obj; +static struct env_iterator_obj _g_env_iter_obj; /** * @brief Traversing from scratch * */ -void env_iterator_to_first() +void ef_env_iterator_to_first() { - obj.sector.addr = FAILED_ADDR; - obj.env.addr.start = FAILED_ADDR; + _g_env_iter_obj.sector.addr = FAILED_ADDR; + _g_env_iter_obj.env.addr.start = FAILED_ADDR; +} +/** + * @brief get the name of env now + * + * @return char* name + */ +char *ef_env_iterator_now_name() +{ + return _g_env_iter_obj.env.name; +} +/** + * @brief get the size of value + * + * @return size_t the size of value + */ +size_t ef_env_iterator_now_value_len() +{ + return _g_env_iter_obj.env.value_len; +} +/** + * @brief get value of env now + * + * @param value_buf ENV blob buffer + * @param buf_len value_buf length + * @return size_t 0:Read the complete;nonzero:unread length + */ +size_t f_env_iterator_now_value(void *value_buf, size_t buf_len) +{ + if(buf_len < _g_env_iter_obj.env.value_len) + { + ef_port_read(_g_env_iter_obj.env.addr.value, (uint32_t *) value_buf, buf_len); + return _g_env_iter_obj.env.value_len - buf_len; + } + else + { + ef_port_read(_g_env_iter_obj.env.addr.value, (uint32_t *) value_buf, _g_env_iter_obj.env.value_len); + return 0; + } + + } - /** * @brief Get next blob ENV * @@ -1185,40 +1224,34 @@ void env_iterator_to_first() * @param value_len ENV blob buffer length * @return char 1:Traversal complete 0:Traversal not complete */ -char env_iterator_next(char *key, void *value_buf, size_t *value_len) +char ef_env_iterator_next() { uint32_t sec_addr; ef_port_env_lock(); - if (obj.sector.addr == FAILED_ADDR) + if (_g_env_iter_obj.sector.addr == FAILED_ADDR) { _reload: - if ((sec_addr = get_next_sector_addr(&obj.sector)) == FAILED_ADDR) + if ((sec_addr = get_next_sector_addr(&_g_env_iter_obj.sector)) == FAILED_ADDR) { ef_port_env_unlock(); return 1; } - if (read_sector_meta_data(sec_addr, &obj.sector, false) != EF_NO_ERR) + if (read_sector_meta_data(sec_addr, &_g_env_iter_obj.sector, false) != EF_NO_ERR) { goto _reload; } } - - if (obj.sector.status.store == SECTOR_STORE_USING || obj.sector.status.store == SECTOR_STORE_FULL) + if (_g_env_iter_obj.sector.status.store == SECTOR_STORE_USING || _g_env_iter_obj.sector.status.store == SECTOR_STORE_FULL) { /* search all ENV */ _next: - if ((obj.env.addr.start = get_next_env_addr(&obj.sector, &obj.env)) != FAILED_ADDR) + if ((_g_env_iter_obj.env.addr.start = get_next_env_addr(&_g_env_iter_obj.sector, &_g_env_iter_obj.env)) != FAILED_ADDR) { - read_env(&obj.env); + read_env(&_g_env_iter_obj.env); /* iterator is interrupted when callback return true */ - if (obj.env.status == ENV_WRITE) + if (_g_env_iter_obj.env.status == ENV_WRITE) { - //key = obj.env.name; - memcpy(key, obj.env.name, obj.env.name_len); - key[obj.env.name_len] = 0; - *value_len = obj.env.value_len; - ef_port_read(obj.env.addr.value, (uint32_t *) value_buf, *value_len); - + _g_env_iter_obj.env.name[_g_env_iter_obj.env.name_len] = 0; ef_port_env_unlock(); return 0; } @@ -1226,13 +1259,11 @@ _next: { goto _next; } - } else { goto _reload; } - } else { From 1f3e28087d4611c0de54b0a6ab36e550b03ef381 Mon Sep 17 00:00:00 2001 From: brand Date: Wed, 20 Nov 2019 18:16:33 +0800 Subject: [PATCH 3/4] =?UTF-8?q?=E6=9B=B4=E6=94=B9next=E7=9B=B4=E6=8E=A5?= =?UTF-8?q?=E8=BF=94=E5=9B=9E=E9=95=BF=E5=BA=A6=E5=92=8C=E5=90=8D=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- easyflash/inc/easyflash.h | 2 +- easyflash/src/ef_env.c | 708 ++++++++++++++++++++++++++------------ 2 files changed, 481 insertions(+), 229 deletions(-) diff --git a/easyflash/inc/easyflash.h b/easyflash/inc/easyflash.h index d88aab5..38a39bf 100644 --- a/easyflash/inc/easyflash.h +++ b/easyflash/inc/easyflash.h @@ -117,7 +117,7 @@ void ef_env_iterator_to_first(void); char *ef_env_iterator_now_name(void); size_t ef_env_iterator_now_value_len(void); size_t ef_env_iterator_now_value(void *value_buf, size_t buf_len); -char ef_env_iterator_next(void); +char* ef_env_iterator_next(size_t *value_len); #endif #ifdef EF_USING_IAP diff --git a/easyflash/src/ef_env.c b/easyflash/src/ef_env.c index 680ea88..6ca2402 100644 --- a/easyflash/src/ef_env.c +++ b/easyflash/src/ef_env.c @@ -136,7 +136,8 @@ #define VER_NUM_ENV_NAME "__ver_num__" -enum sector_store_status { +enum sector_store_status +{ SECTOR_STORE_UNUSED, SECTOR_STORE_EMPTY, SECTOR_STORE_USING, @@ -145,7 +146,8 @@ enum sector_store_status { }; typedef enum sector_store_status sector_store_status_t; -enum sector_dirty_status { +enum sector_dirty_status +{ SECTOR_DIRTY_UNUSED, SECTOR_DIRTY_FALSE, SECTOR_DIRTY_TRUE, @@ -154,7 +156,8 @@ enum sector_dirty_status { }; typedef enum sector_dirty_status sector_dirty_status_t; -enum env_status { +enum env_status +{ ENV_UNUSED, ENV_PRE_WRITE, ENV_WRITE, @@ -165,8 +168,10 @@ enum env_status { }; typedef enum env_status env_status_t; -struct sector_hdr_data { - struct { +struct sector_hdr_data +{ + struct + { uint8_t store[STORE_STATUS_TABLE_SIZE]; /**< sector store status @see sector_store_status_t */ uint8_t dirty[DIRTY_STATUS_TABLE_SIZE]; /**< sector dirty status @see sector_dirty_status_t */ } status_table; @@ -176,9 +181,11 @@ struct sector_hdr_data { }; typedef struct sector_hdr_data *sector_hdr_data_t; -struct sector_meta_data { +struct sector_meta_data +{ bool check_ok; /**< sector header check is OK */ - struct { + struct + { sector_store_status_t store; /**< sector store status @see sector_store_status_t */ sector_dirty_status_t dirty; /**< sector dirty status @see sector_dirty_status_t */ } status; @@ -190,7 +197,8 @@ struct sector_meta_data { }; typedef struct sector_meta_data *sector_meta_data_t; -struct env_hdr_data { +struct env_hdr_data +{ uint8_t status_table[ENV_STATUS_TABLE_SIZE]; /**< ENV node status, @see node_status_t */ uint32_t magic; /**< magic word(`K`, `V`, `4`, `0`) */ uint32_t len; /**< ENV node total length (header + name + value), must align by EF_WRITE_GRAN */ @@ -200,7 +208,8 @@ struct env_hdr_data { }; typedef struct env_hdr_data *env_hdr_data_t; -struct env_meta_data { +struct env_meta_data +{ env_status_t status; /**< ENV node status, @see node_status_t */ bool crc_is_ok; /**< ENV node CRC32 check is OK */ uint8_t name_len; /**< name length */ @@ -208,7 +217,8 @@ struct env_meta_data { uint32_t len; /**< ENV node total length (header + name + value), must align by EF_WRITE_GRAN */ uint32_t value_len; /**< value length */ char name[EF_ENV_NAME_MAX]; /**< name */ - struct { + struct + { uint32_t start; /**< ENV node start address */ uint32_t value; /**< value start address */ } addr; @@ -222,14 +232,16 @@ struct env_iterator_obj }; typedef struct env_iterator_obj *env_iterator_obj_t; -struct env_cache_node { +struct env_cache_node +{ uint16_t name_crc; /**< ENV name's CRC32 low 16bit value */ uint16_t active; /**< ENV node access active degree */ uint32_t addr; /**< ENV node address */ }; typedef struct env_cache_node *env_cache_node_t; -struct sector_cache_node { +struct sector_cache_node +{ uint32_t addr; /**< sector start address */ uint32_t empty_addr; /**< sector empty address */ }; @@ -268,7 +280,8 @@ static size_t set_status(uint8_t status_table[], size_t status_num, size_t statu * | 32bit | 0xFFFFFFFF FFFFFFFF | 0x00FFFFFF FFFFFFFF | 0x00FFFFFF 00FFFFFF | */ memset(status_table, 0xFF, STATUS_TABLE_SIZE(status_num)); - if (status_index > 0) { + if (status_index > 0) + { #if (EF_WRITE_GRAN == 1) byte_index = (status_index - 1) / 8; status_table[byte_index] &= ~(0x80 >> ((status_index - 1) % 8)); @@ -285,14 +298,17 @@ static size_t get_status(uint8_t status_table[], size_t status_num) { size_t i = 0, status_num_bak = --status_num; - while (status_num --) { + while (status_num --) + { /* get the first 0 position from end address to start address */ #if (EF_WRITE_GRAN == 1) - if ((status_table[status_num / 8] & (0x80 >> (status_num % 8))) == 0x00) { + if ((status_table[status_num / 8] & (0x80 >> (status_num % 8))) == 0x00) + { break; } #else /* (EF_WRITE_GRAN == 8) || (EF_WRITE_GRAN == 32) || (EF_WRITE_GRAN == 64) */ - if (status_table[status_num * EF_WRITE_GRAN / 8] == 0x00) { + if (status_table[status_num * EF_WRITE_GRAN / 8] == 0x00) + { break; } #endif /* EF_WRITE_GRAN == 1 */ @@ -314,7 +330,8 @@ static EfErrCode write_status(uint32_t addr, uint8_t status_table[], size_t stat byte_index = set_status(status_table, status_num, status_index); /* the first status table value is all 1, so no need to write flash */ - if (byte_index == ~0UL) { + if (byte_index == ~0UL) + { return EF_NO_ERR; } #if (EF_WRITE_GRAN == 1) @@ -345,24 +362,32 @@ static void update_sector_cache(uint32_t sec_addr, uint32_t empty_addr) { size_t i, empty_index = EF_SECTOR_CACHE_TABLE_SIZE; - for (i = 0; i < EF_SECTOR_CACHE_TABLE_SIZE; i++) { - if ((empty_addr > sec_addr) && (empty_addr < sec_addr + SECTOR_SIZE)) { + for (i = 0; i < EF_SECTOR_CACHE_TABLE_SIZE; i++) + { + if ((empty_addr > sec_addr) && (empty_addr < sec_addr + SECTOR_SIZE)) + { /* update the sector empty_addr in cache */ - if (sector_cache_table[i].addr == sec_addr) { + if (sector_cache_table[i].addr == sec_addr) + { sector_cache_table[i].addr = sec_addr; sector_cache_table[i].empty_addr = empty_addr; return; - } else if ((sector_cache_table[i].addr == FAILED_ADDR) && (empty_index == EF_SECTOR_CACHE_TABLE_SIZE)) { + } + else if ((sector_cache_table[i].addr == FAILED_ADDR) && (empty_index == EF_SECTOR_CACHE_TABLE_SIZE)) + { empty_index = i; } - } else if (sector_cache_table[i].addr == sec_addr) { + } + else if (sector_cache_table[i].addr == sec_addr) + { /* delete the sector which status is not current using */ sector_cache_table[i].addr = FAILED_ADDR; return; } } /* add the sector empty_addr to cache */ - if (empty_index < EF_SECTOR_CACHE_TABLE_SIZE) { + if (empty_index < EF_SECTOR_CACHE_TABLE_SIZE) + { sector_cache_table[empty_index].addr = sec_addr; sector_cache_table[empty_index].empty_addr = empty_addr; } @@ -375,9 +400,12 @@ static bool get_sector_from_cache(uint32_t sec_addr, uint32_t *empty_addr) { size_t i; - for (i = 0; i < EF_SECTOR_CACHE_TABLE_SIZE; i++) { - if (sector_cache_table[i].addr == sec_addr) { - if (empty_addr) { + for (i = 0; i < EF_SECTOR_CACHE_TABLE_SIZE; i++) + { + if (sector_cache_table[i].addr == sec_addr) + { + if (empty_addr) + { *empty_addr = sector_cache_table[i].empty_addr; } return true; @@ -392,24 +420,35 @@ static void update_env_cache(const char *name, size_t name_len, uint32_t addr) size_t i, empty_index = EF_ENV_CACHE_TABLE_SIZE, min_activity_index = EF_ENV_CACHE_TABLE_SIZE; uint16_t name_crc = (uint16_t) (ef_calc_crc32(0, name, name_len) >> 16), min_activity = 0xFFFF; - for (i = 0; i < EF_ENV_CACHE_TABLE_SIZE; i++) { - if (addr != FAILED_ADDR) { + for (i = 0; i < EF_ENV_CACHE_TABLE_SIZE; i++) + { + if (addr != FAILED_ADDR) + { /* update the ENV address in cache */ - if (env_cache_table[i].name_crc == name_crc) { + if (env_cache_table[i].name_crc == name_crc) + { env_cache_table[i].addr = addr; return; - } else if ((env_cache_table[i].addr == FAILED_ADDR) && (empty_index == EF_ENV_CACHE_TABLE_SIZE)) { + } + else if ((env_cache_table[i].addr == FAILED_ADDR) && (empty_index == EF_ENV_CACHE_TABLE_SIZE)) + { empty_index = i; - } else if (env_cache_table[i].addr != FAILED_ADDR) { - if (env_cache_table[i].active > 0) { + } + else if (env_cache_table[i].addr != FAILED_ADDR) + { + if (env_cache_table[i].active > 0) + { env_cache_table[i].active--; } - if (env_cache_table[i].active < min_activity) { + if (env_cache_table[i].active < min_activity) + { min_activity_index = i; min_activity = env_cache_table[i].active; } } - } else if (env_cache_table[i].name_crc == name_crc) { + } + else if (env_cache_table[i].name_crc == name_crc) + { /* delete the ENV */ env_cache_table[i].addr = FAILED_ADDR; env_cache_table[i].active = 0; @@ -417,11 +456,14 @@ static void update_env_cache(const char *name, size_t name_len, uint32_t addr) } } /* add the ENV to cache, using LRU (Least Recently Used) like algorithm */ - if (empty_index < EF_ENV_CACHE_TABLE_SIZE) { + if (empty_index < EF_ENV_CACHE_TABLE_SIZE) + { env_cache_table[empty_index].addr = addr; env_cache_table[empty_index].name_crc = name_crc; env_cache_table[empty_index].active = 0; - } else if (min_activity_index < EF_ENV_CACHE_TABLE_SIZE) { + } + else if (min_activity_index < EF_ENV_CACHE_TABLE_SIZE) + { env_cache_table[min_activity_index].addr = addr; env_cache_table[min_activity_index].name_crc = name_crc; env_cache_table[min_activity_index].active = 0; @@ -436,16 +478,22 @@ static bool get_env_from_cache(const char *name, size_t name_len, uint32_t *addr size_t i; uint16_t name_crc = (uint16_t) (ef_calc_crc32(0, name, name_len) >> 16); - for (i = 0; i < EF_ENV_CACHE_TABLE_SIZE; i++) { - if ((env_cache_table[i].addr != FAILED_ADDR) && (env_cache_table[i].name_crc == name_crc)) { + for (i = 0; i < EF_ENV_CACHE_TABLE_SIZE; i++) + { + if ((env_cache_table[i].addr != FAILED_ADDR) && (env_cache_table[i].name_crc == name_crc)) + { char saved_name[EF_ENV_NAME_MAX]; /* read the ENV name in flash */ ef_port_read(env_cache_table[i].addr + ENV_HDR_DATA_SIZE, (uint32_t *) saved_name, EF_ENV_NAME_MAX); - if (!strncmp(name, saved_name, name_len)) { + if (!strncmp(name, saved_name, name_len)) + { *addr = env_cache_table[i].addr; - if (env_cache_table[i].active >= 0xFFFF - EF_ENV_CACHE_TABLE_SIZE) { + if (env_cache_table[i].active >= 0xFFFF - EF_ENV_CACHE_TABLE_SIZE) + { env_cache_table[i].active = 0xFFFF; - } else { + } + else + { env_cache_table[i].active += EF_ENV_CACHE_TABLE_SIZE; } return true; @@ -465,24 +513,33 @@ static uint32_t continue_ff_addr(uint32_t start, uint32_t end) uint8_t buf[32], last_data = 0x00; size_t i, addr = start, read_size; - for (; start < end; start += sizeof(buf)) { - if (start + sizeof(buf) < end) { + for (; start < end; start += sizeof(buf)) + { + if (start + sizeof(buf) < end) + { read_size = sizeof(buf); - } else { + } + else + { read_size = end - start; } ef_port_read(start, (uint32_t *) buf, read_size); - for (i = 0; i < read_size; i++) { - if (last_data != 0xFF && buf[i] == 0xFF) { + for (i = 0; i < read_size; i++) + { + if (last_data != 0xFF && buf[i] == 0xFF) + { addr = start + i; } last_data = buf[i]; } } - if (last_data == 0xFF) { + if (last_data == 0xFF) + { return EF_WG_ALIGN(addr); - } else { + } + else + { return end; } } @@ -499,20 +556,24 @@ static uint32_t find_next_env_addr(uint32_t start, uint32_t end) #ifdef EF_ENV_USING_CACHE uint32_t empty_env; - if (get_sector_from_cache(EF_ALIGN_DOWN(start, SECTOR_SIZE), &empty_env) && start == empty_env) { + if (get_sector_from_cache(EF_ALIGN_DOWN(start, SECTOR_SIZE), &empty_env) && start == empty_env) + { return FAILED_ADDR; } #endif /* EF_ENV_USING_CACHE */ - for (; start < end; start += (sizeof(buf) - sizeof(uint32_t))) { + for (; start < end; start += (sizeof(buf) - sizeof(uint32_t))) + { ef_port_read(start, (uint32_t *) buf, sizeof(buf)); - for (i = 0; i < sizeof(buf) - sizeof(uint32_t) && start + i < end; i++) { + for (i = 0; i < sizeof(buf) - sizeof(uint32_t) && start + i < end; i++) + { #ifndef EF_BIG_ENDIAN /* Little Endian Order */ magic = buf[i] + (buf[i + 1] << 8) + (buf[i + 2] << 16) + (buf[i + 3] << 24); #else // Big Endian Order magic = buf[i + 3] + (buf[i + 2] << 8) + (buf[i + 1] << 16) + (buf[i] << 24); #endif - if (magic == ENV_MAGIC_WORD && (start + i - ENV_MAGIC_OFFSET) >= start_bak) { + if (magic == ENV_MAGIC_WORD && (start + i - ENV_MAGIC_OFFSET) >= start_bak) + { return start + i - ENV_MAGIC_OFFSET; } } @@ -525,18 +586,26 @@ static uint32_t get_next_env_addr(sector_meta_data_t sector, env_meta_data_t pre { uint32_t addr = FAILED_ADDR; - if (sector->status.store == SECTOR_STORE_EMPTY) { + if (sector->status.store == SECTOR_STORE_EMPTY) + { return FAILED_ADDR; } - if (pre_env->addr.start == FAILED_ADDR) { + if (pre_env->addr.start == FAILED_ADDR) + { /* the first ENV address */ addr = sector->addr + SECTOR_HDR_DATA_SIZE; - } else { - if (pre_env->addr.start <= sector->addr + SECTOR_SIZE) { - if (pre_env->crc_is_ok) { + } + else + { + if (pre_env->addr.start <= sector->addr + SECTOR_SIZE) + { + if (pre_env->crc_is_ok) + { addr = pre_env->addr.start + pre_env->len; - } else { + } + else + { /* when pre_env CRC check failed, maybe the flash has error data * find_next_env_addr after pre_env address */ addr = pre_env->addr.start + EF_WG_ALIGN(1); @@ -544,11 +613,14 @@ static uint32_t get_next_env_addr(sector_meta_data_t sector, env_meta_data_t pre /* check and find next ENV address */ addr = find_next_env_addr(addr, sector->addr + SECTOR_SIZE - SECTOR_HDR_DATA_SIZE); - if (addr > sector->addr + SECTOR_SIZE || pre_env->len == 0) { + if (addr > sector->addr + SECTOR_SIZE || pre_env->len == 0) + { //TODO 扇区连续模式 return FAILED_ADDR; } - } else { + } + else + { /* no ENV */ return FAILED_ADDR; } @@ -569,17 +641,21 @@ static EfErrCode read_env(env_meta_data_t env) env->status = (env_status_t) get_status(env_hdr.status_table, ENV_STATUS_NUM); env->len = env_hdr.len; - if (env->len == ~0UL || env->len > ENV_AREA_SIZE || env->len < ENV_NAME_LEN_OFFSET) { + if (env->len == ~0UL || env->len > ENV_AREA_SIZE || env->len < ENV_NAME_LEN_OFFSET) + { /* the ENV length was not write, so reserved the meta data for current ENV */ env->len = ENV_HDR_DATA_SIZE; - if (env->status != ENV_ERR_HDR) { + if (env->status != ENV_ERR_HDR) + { env->status = ENV_ERR_HDR; EF_DEBUG("Error: The ENV @0x%08X length has an error.\n", env->addr.start); write_status(env->addr.start, env_hdr.status_table, ENV_STATUS_NUM, ENV_ERR_HDR); } env->crc_is_ok = false; return EF_READ_ERR; - } else if (env->len > SECTOR_SIZE - SECTOR_HDR_DATA_SIZE && env->len < ENV_AREA_SIZE) { + } + else if (env->len > SECTOR_SIZE - SECTOR_HDR_DATA_SIZE && env->len < ENV_AREA_SIZE) + { //TODO 扇区连续模式，或者写入长度没有写入完整 EF_ASSERT(0); } @@ -587,10 +663,14 @@ static EfErrCode read_env(env_meta_data_t env) /* CRC32 data len(header.name_len + header.value_len + name + value) */ crc_data_len = env->len - ENV_NAME_LEN_OFFSET; /* calculate the CRC32 value */ - for (len = 0, size = 0; len < crc_data_len; len += size) { - if (len + sizeof(buf) < crc_data_len) { + for (len = 0, size = 0; len < crc_data_len; len += size) + { + if (len + sizeof(buf) < crc_data_len) + { size = sizeof(buf); - } else { + } + else + { size = crc_data_len - len; } @@ -598,10 +678,13 @@ static EfErrCode read_env(env_meta_data_t env) calc_crc32 = ef_calc_crc32(calc_crc32, buf, size); } /* check CRC32 */ - if (calc_crc32 != env_hdr.crc32) { + if (calc_crc32 != env_hdr.crc32) + { env->crc_is_ok = false; result = EF_READ_ERR; - } else { + } + else + { env->crc_is_ok = true; /* the name is behind aligned ENV header */ env_name_addr = env->addr.start + ENV_HDR_DATA_SIZE; @@ -629,7 +712,8 @@ static EfErrCode read_sector_meta_data(uint32_t addr, sector_meta_data_t sector, sector->addr = addr; sector->magic = sec_hdr.magic; /* check magic word */ - if (sector->magic != SECTOR_MAGIC_WORD) { + if (sector->magic != SECTOR_MAGIC_WORD) + { sector->check_ok = false; sector->combined = SECTOR_NOT_COMBINED; return EF_ENV_INIT_FAILED; @@ -640,16 +724,21 @@ static EfErrCode read_sector_meta_data(uint32_t addr, sector_meta_data_t sector, sector->status.store = (sector_store_status_t) get_status(sec_hdr.status_table.store, SECTOR_STORE_STATUS_NUM); sector->status.dirty = (sector_dirty_status_t) get_status(sec_hdr.status_table.dirty, SECTOR_DIRTY_STATUS_NUM); /* traversal all ENV and calculate the remain space size */ - if (traversal) { + if (traversal) + { sector->remain = 0; sector->empty_env = sector->addr + SECTOR_HDR_DATA_SIZE; - if (sector->status.store == SECTOR_STORE_EMPTY) { + if (sector->status.store == SECTOR_STORE_EMPTY) + { sector->remain = SECTOR_SIZE - SECTOR_HDR_DATA_SIZE; - } else if (sector->status.store == SECTOR_STORE_USING) { + } + else if (sector->status.store == SECTOR_STORE_USING) + { struct env_meta_data env_meta; #ifdef EF_ENV_USING_CACHE - if (get_sector_from_cache(addr, §or->empty_env)) { + if (get_sector_from_cache(addr, §or->empty_env)) + { sector->remain = SECTOR_SIZE - (sector->empty_env - sector->addr); return result; } @@ -657,10 +746,13 @@ static EfErrCode read_sector_meta_data(uint32_t addr, sector_meta_data_t sector, sector->remain = SECTOR_SIZE - SECTOR_HDR_DATA_SIZE; env_meta.addr.start = FAILED_ADDR; - while ((env_meta.addr.start = get_next_env_addr(sector, &env_meta)) != FAILED_ADDR) { + while ((env_meta.addr.start = get_next_env_addr(sector, &env_meta)) != FAILED_ADDR) + { read_env(&env_meta); - if (!env_meta.crc_is_ok) { - if (env_meta.status != ENV_PRE_WRITE && env_meta.status!= ENV_ERR_HDR) { + if (!env_meta.crc_is_ok) + { + if (env_meta.status != ENV_PRE_WRITE && env_meta.status != ENV_ERR_HDR) + { EF_INFO("Error: The ENV (@0x%08X) CRC32 check failed!\n", env_meta.addr.start); sector->remain = 0; result = EF_READ_ERR; @@ -676,7 +768,8 @@ static EfErrCode read_sector_meta_data(uint32_t addr, sector_meta_data_t sector, ff_addr = continue_ff_addr(sector->empty_env, sector->addr + SECTOR_SIZE); /* check the flash data is clean */ - if (sector->empty_env != ff_addr) { + if (sector->empty_env != ff_addr) + { /* update the sector information */ sector->empty_env = ff_addr; sector->remain = SECTOR_SIZE - (ff_addr - sector->addr); @@ -696,19 +789,28 @@ static uint32_t get_next_sector_addr(sector_meta_data_t pre_sec) { uint32_t next_addr; - if (pre_sec->addr == FAILED_ADDR) { + if (pre_sec->addr == FAILED_ADDR) + { return env_start_addr; - } else { + } + else + { /* check ENV sector combined */ - if (pre_sec->combined == SECTOR_NOT_COMBINED) { + if (pre_sec->combined == SECTOR_NOT_COMBINED) + { next_addr = pre_sec->addr + SECTOR_SIZE; - } else { + } + else + { next_addr = pre_sec->addr + pre_sec->combined * SECTOR_SIZE; } /* check range */ - if (next_addr < env_start_addr + ENV_AREA_SIZE) { + if (next_addr < env_start_addr + ENV_AREA_SIZE) + { return next_addr; - } else { + } + else + { /* no sector */ return FAILED_ADDR; } @@ -716,28 +818,34 @@ static uint32_t get_next_sector_addr(sector_meta_data_t pre_sec) } static void env_iterator(env_meta_data_t env, void *arg1, void *arg2, - bool (*callback)(env_meta_data_t env, void *arg1, void *arg2)) + bool (*callback)(env_meta_data_t env, void *arg1, void *arg2)) { struct sector_meta_data sector; uint32_t sec_addr; sector.addr = FAILED_ADDR; /* search all sectors */ - while ((sec_addr = get_next_sector_addr(§or)) != FAILED_ADDR) { - if (read_sector_meta_data(sec_addr, §or, false) != EF_NO_ERR) { + while ((sec_addr = get_next_sector_addr(§or)) != FAILED_ADDR) + { + if (read_sector_meta_data(sec_addr, §or, false) != EF_NO_ERR) + { continue; } - if (callback == NULL) { + if (callback == NULL) + { continue; } /* sector has ENV */ - if (sector.status.store == SECTOR_STORE_USING || sector.status.store == SECTOR_STORE_FULL) { + if (sector.status.store == SECTOR_STORE_USING || sector.status.store == SECTOR_STORE_FULL) + { env->addr.start = FAILED_ADDR; /* search all ENV */ - while ((env->addr.start = get_next_env_addr(§or, env)) != FAILED_ADDR) { + while ((env->addr.start = get_next_env_addr(§or, env)) != FAILED_ADDR) + { read_env(env); /* iterator is interrupted when callback return true */ - if (callback(env, arg1, arg2)) { + if (callback(env, arg1, arg2)) + { return; } } @@ -751,11 +859,13 @@ static bool find_env_cb(env_meta_data_t env, void *arg1, void *arg2) bool *find_ok = arg2; uint8_t max_len = strlen(key); - if (max_len < env->name_len) { + if (max_len < env->name_len) + { max_len = env->name_len; } /* check ENV */ - if (env->crc_is_ok && env->status == ENV_WRITE && !strncmp(env->name, key, max_len)) { + if (env->crc_is_ok && env->status == ENV_WRITE && !strncmp(env->name, key, max_len)) + { *find_ok = true; return true; } @@ -778,7 +888,8 @@ static bool find_env(const char *key, env_meta_data_t env) #ifdef EF_ENV_USING_CACHE size_t key_len = strlen(key); - if (get_env_from_cache(key, key_len, &env->addr.start)) { + if (get_env_from_cache(key, key_len, &env->addr.start)) + { read_env(env); return true; } @@ -787,7 +898,8 @@ static bool find_env(const char *key, env_meta_data_t env) find_ok = find_env_no_cache(key, env); #ifdef EF_ENV_USING_CACHE - if (find_ok) { + if (find_ok) + { update_env_cache(key, key_len, env->addr.start); } #endif /* EF_ENV_USING_CACHE */ @@ -800,8 +912,10 @@ static bool ef_is_str(uint8_t *value, size_t len) #define __is_print(ch) ((unsigned int)((ch) - ' ') < 127u - ' ') size_t i; - for (i = 0; i < len; i++) { - if (!__is_print(value[i])) { + for (i = 0; i < len; i++) + { + if (!__is_print(value[i])) + { return false; } } @@ -813,16 +927,22 @@ static size_t get_env(const char *key, void *value_buf, size_t buf_len, size_t * struct env_meta_data env; size_t read_len = 0; - if (find_env(key, &env)) { - if (value_len) { + if (find_env(key, &env)) + { + if (value_len) + { *value_len = env.value_len; } - if (buf_len > env.value_len) { + if (buf_len > env.value_len) + { read_len = env.value_len; - } else { + } + else + { read_len = buf_len; } - if (value_buf){ + if (value_buf) + { ef_port_read(env.addr.value, (uint32_t *) value_buf, read_len); } } @@ -844,7 +964,8 @@ size_t ef_get_env_blob(const char *key, void *value_buf, size_t buf_len, size_t { size_t read_len = 0; - if (!init_ok) { + if (!init_ok) + { EF_INFO("ENV isn't initialize OK.\n"); return 0; } @@ -875,12 +996,16 @@ char *ef_get_env(const char *key) static char value[EF_STR_ENV_VALUE_MAX_SIZE + 1]; size_t get_size; - if ((get_size = ef_get_env_blob(key, value, EF_STR_ENV_VALUE_MAX_SIZE, NULL)) > 0) { + if ((get_size = ef_get_env_blob(key, value, EF_STR_ENV_VALUE_MAX_SIZE, NULL)) > 0) + { /* the return value must be string */ - if (ef_is_str((uint8_t *)value, get_size)) { + if (ef_is_str((uint8_t *)value, get_size)) + { value[get_size] = '\0'; return value; - } else { + } + else + { EF_INFO("Warning: The ENV value isn't string. Could not be returned\n"); return NULL; } @@ -889,11 +1014,13 @@ char *ef_get_env(const char *key) return NULL; } -static EfErrCode write_env_hdr(uint32_t addr, env_hdr_data_t env_hdr) { +static EfErrCode write_env_hdr(uint32_t addr, env_hdr_data_t env_hdr) +{ EfErrCode result = EF_NO_ERR; /* write the status will by write granularity */ result = write_status(addr, env_hdr->status_table, ENV_STATUS_NUM, ENV_PRE_WRITE); - if (result != EF_NO_ERR) { + if (result != EF_NO_ERR) + { return result; } /* write other header data */ @@ -910,7 +1037,8 @@ static EfErrCode format_sector(uint32_t addr, uint32_t combined_value) EF_ASSERT(addr % SECTOR_SIZE == 0); result = ef_port_erase(addr, SECTOR_SIZE); - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { /* initialize the header data */ memset(&sec_hdr, 0xFF, sizeof(struct sector_hdr_data)); set_status(sec_hdr.status_table.store, SECTOR_STORE_STATUS_NUM, SECTOR_STORE_EMPTY); @@ -935,12 +1063,16 @@ static EfErrCode update_sec_status(sector_meta_data_t sector, size_t new_env_len uint8_t status_table[STORE_STATUS_TABLE_SIZE]; EfErrCode result = EF_NO_ERR; /* change the current sector status */ - if (sector->status.store == SECTOR_STORE_EMPTY) { + if (sector->status.store == SECTOR_STORE_EMPTY) + { /* change the sector status to using */ result = write_status(sector->addr, status_table, SECTOR_STORE_STATUS_NUM, SECTOR_STORE_USING); - } else if (sector->status.store == SECTOR_STORE_USING) { + } + else if (sector->status.store == SECTOR_STORE_USING) + { /* check remain size */ - if (sector->remain < EF_SEC_REMAIN_THRESHOLD || sector->remain - new_env_len < EF_SEC_REMAIN_THRESHOLD) { + if (sector->remain < EF_SEC_REMAIN_THRESHOLD || sector->remain - new_env_len < EF_SEC_REMAIN_THRESHOLD) + { /* change the sector status to full */ result = write_status(sector->addr, status_table, SECTOR_STORE_STATUS_NUM, SECTOR_STORE_FULL); @@ -949,10 +1081,13 @@ static EfErrCode update_sec_status(sector_meta_data_t sector, size_t new_env_len update_sector_cache(sector->addr, sector->addr + SECTOR_SIZE); #endif /* EF_ENV_USING_CACHE */ - if (is_full) { + if (is_full) + { *is_full = true; } - } else if (is_full) { + } + else if (is_full) + { *is_full = false; } } @@ -961,19 +1096,24 @@ static EfErrCode update_sec_status(sector_meta_data_t sector, size_t new_env_len } static void sector_iterator(sector_meta_data_t sector, sector_store_status_t status, void *arg1, void *arg2, - bool (*callback)(sector_meta_data_t sector, void *arg1, void *arg2), bool traversal_env) { + bool (*callback)(sector_meta_data_t sector, void *arg1, void *arg2), bool traversal_env) +{ uint32_t sec_addr; /* search all sectors */ sector->addr = FAILED_ADDR; - while ((sec_addr = get_next_sector_addr(sector)) != FAILED_ADDR) { + while ((sec_addr = get_next_sector_addr(sector)) != FAILED_ADDR) + { read_sector_meta_data(sec_addr, sector, false); - if (status == SECTOR_STORE_UNUSED || status == sector->status.store) { - if (traversal_env) { + if (status == SECTOR_STORE_UNUSED || status == sector->status.store) + { + if (traversal_env) + { read_sector_meta_data(sec_addr, sector, traversal_env); } /* iterator is interrupted when callback return true */ - if (callback && callback(sector, arg1, arg2)) { + if (callback && callback(sector, arg1, arg2)) + { return; } } @@ -984,9 +1124,12 @@ static bool sector_statistics_cb(sector_meta_data_t sector, void *arg1, void *ar { size_t *empty_sector = arg1, *using_sector = arg2; - if (sector->check_ok && sector->status.store == SECTOR_STORE_EMPTY) { + if (sector->check_ok && sector->status.store == SECTOR_STORE_EMPTY) + { (*empty_sector)++; - } else if (sector->check_ok && sector->status.store == SECTOR_STORE_USING) { + } + else if (sector->check_ok && sector->status.store == SECTOR_STORE_USING) + { (*using_sector)++; } @@ -1003,7 +1146,8 @@ static bool alloc_env_cb(sector_meta_data_t sector, void *arg1, void *arg2) * 3. the dirty sector only when the gc_request is false */ if (sector->check_ok && sector->remain > *env_size && ((sector->status.dirty == SECTOR_DIRTY_FALSE) - || (sector->status.dirty == SECTOR_DIRTY_TRUE && !gc_request))) { + || (sector->status.dirty == SECTOR_DIRTY_TRUE && !gc_request))) + { *empty_env = sector->empty_env; return true; } @@ -1018,14 +1162,19 @@ static uint32_t alloc_env(sector_meta_data_t sector, size_t env_size) /* sector status statistics */ sector_iterator(sector, SECTOR_STORE_UNUSED, &empty_sector, &using_sector, sector_statistics_cb, false); - if (using_sector > 0) { + if (using_sector > 0) + { /* alloc the ENV from the using status sector first */ sector_iterator(sector, SECTOR_STORE_USING, &env_size, &empty_env, alloc_env_cb, true); } - if (empty_sector > 0 && empty_env == FAILED_ADDR) { - if (empty_sector > EF_GC_EMPTY_SEC_THRESHOLD || gc_request) { + if (empty_sector > 0 && empty_env == FAILED_ADDR) + { + if (empty_sector > EF_GC_EMPTY_SEC_THRESHOLD || gc_request) + { sector_iterator(sector, SECTOR_STORE_EMPTY, &env_size, &empty_env, alloc_env_cb, true); - } else { + } + else + { /* no space for new ENV now will GC and retry */ EF_DEBUG("Trigger a GC check after alloc ENV failed.\n"); gc_request = true; @@ -1035,7 +1184,8 @@ static uint32_t alloc_env(sector_meta_data_t sector, size_t env_size) return empty_env; } -static EfErrCode del_env(const char *key, env_meta_data_t old_env, bool complete_del) { +static EfErrCode del_env(const char *key, env_meta_data_t old_env, bool complete_del) +{ EfErrCode result = EF_NO_ERR; uint32_t dirty_status_addr; static bool last_is_complete_del = false; @@ -1047,24 +1197,32 @@ static EfErrCode del_env(const char *key, env_meta_data_t old_env, bool complete #endif /* need find ENV */ - if (!old_env) { + if (!old_env) + { struct env_meta_data env; /* find ENV */ - if (find_env(key, &env)) { + if (find_env(key, &env)) + { old_env = &env; - } else { + } + else + { EF_DEBUG("Not found '%s' in ENV.\n", key); return EF_ENV_NAME_ERR; } } /* change and save the new status */ - if (!complete_del) { + if (!complete_del) + { result = write_status(old_env->addr.start, status_table, ENV_STATUS_NUM, ENV_PRE_DELETE); last_is_complete_del = true; - } else { + } + else + { result = write_status(old_env->addr.start, status_table, ENV_STATUS_NUM, ENV_DELETED); - if (!last_is_complete_del && result == EF_NO_ERR) { + if (!last_is_complete_del && result == EF_NO_ERR) + { #ifdef EF_ENV_USING_CACHE /* only delete the ENV in flash and cache when only using del_env(key, env, true) in ef_del_env() */ update_env_cache(key, strlen(key), FAILED_ADDR); @@ -1077,7 +1235,8 @@ static EfErrCode del_env(const char *key, env_meta_data_t old_env, bool complete dirty_status_addr = EF_ALIGN_DOWN(old_env->addr.start, SECTOR_SIZE) + SECTOR_DIRTY_OFFSET; /* read and change the sector dirty status */ if (result == EF_NO_ERR - && read_status(dirty_status_addr, status_table, SECTOR_DIRTY_STATUS_NUM) == SECTOR_DIRTY_FALSE) { + && read_status(dirty_status_addr, status_table, SECTOR_DIRTY_STATUS_NUM) == SECTOR_DIRTY_FALSE) + { result = write_status(dirty_status_addr, status_table, SECTOR_DIRTY_STATUS_NUM, SECTOR_DIRTY_TRUE); } @@ -1095,23 +1254,29 @@ static EfErrCode move_env(env_meta_data_t env) struct sector_meta_data sector; /* prepare to delete the current ENV */ - if (env->status == ENV_WRITE) { + if (env->status == ENV_WRITE) + { del_env(NULL, env, false); } - if ((env_addr = alloc_env(§or, env->len)) != FAILED_ADDR) { - if (in_recovery_check) { + if ((env_addr = alloc_env(§or, env->len)) != FAILED_ADDR) + { + if (in_recovery_check) + { struct env_meta_data env_bak; char name[EF_ENV_NAME_MAX + 1] = { 0 }; strncpy(name, env->name, env->name_len); /* check the ENV in flash is already create success */ - if (find_env_no_cache(name, &env_bak)) { + if (find_env_no_cache(name, &env_bak)) + { /* already create success, don't need to duplicate */ result = EF_NO_ERR; goto __exit; } } - } else { + } + else + { return EF_ENV_FULL; } /* start move the ENV */ @@ -1124,10 +1289,14 @@ static EfErrCode move_env(env_meta_data_t env) write_status(env_addr, status_table, ENV_STATUS_NUM, ENV_PRE_WRITE); env_len -= ENV_MAGIC_OFFSET; - for (len = 0, size = 0; len < env_len; len += size) { - if (len + sizeof(buf) < env_len) { + for (len = 0, size = 0; len < env_len; len += size) + { + if (len + sizeof(buf) < env_len) + { size = sizeof(buf); - } else { + } + else + { size = env_len - len; } ef_port_read(env->addr.start + ENV_MAGIC_OFFSET + len, (uint32_t *) buf, EF_WG_ALIGN(size)); @@ -1137,7 +1306,7 @@ static EfErrCode move_env(env_meta_data_t env) #ifdef EF_ENV_USING_CACHE update_sector_cache(EF_ALIGN_DOWN(env_addr, SECTOR_SIZE), - env_addr + ENV_HDR_DATA_SIZE + EF_WG_ALIGN(env->name_len) + EF_WG_ALIGN(env->value_len)); + env_addr + ENV_HDR_DATA_SIZE + EF_WG_ALIGN(env->name_len) + EF_WG_ALIGN(env->value_len)); update_env_cache(env->name, env->name_len, env_addr); #endif /* EF_ENV_USING_CACHE */ } @@ -1157,7 +1326,8 @@ static uint32_t new_env(sector_meta_data_t sector, size_t env_size) __retry: - if ((empty_env = alloc_env(sector, env_size)) == FAILED_ADDR && gc_request && !already_gc) { + if ((empty_env = alloc_env(sector, env_size)) == FAILED_ADDR && gc_request && !already_gc) + { EF_DEBUG("Warning: Alloc an ENV (size %d) failed when new ENV. Now will GC then retry.\n", env_size); gc_collect(); already_gc = true; @@ -1178,7 +1348,7 @@ void ef_env_iterator_to_first() } /** * @brief get the name of env now - * + * * @return char* name */ char *ef_env_iterator_now_name() @@ -1187,7 +1357,7 @@ char *ef_env_iterator_now_name() } /** * @brief get the size of value - * + * * @return size_t the size of value */ size_t ef_env_iterator_now_value_len() @@ -1196,14 +1366,14 @@ size_t ef_env_iterator_now_value_len() } /** * @brief get value of env now - * + * * @param value_buf ENV blob buffer * @param buf_len value_buf length * @return size_t 0:Read the complete;nonzero:unread length */ size_t f_env_iterator_now_value(void *value_buf, size_t buf_len) { - if(buf_len < _g_env_iter_obj.env.value_len) + if (buf_len < _g_env_iter_obj.env.value_len) { ef_port_read(_g_env_iter_obj.env.addr.value, (uint32_t *) value_buf, buf_len); return _g_env_iter_obj.env.value_len - buf_len; @@ -1213,18 +1383,16 @@ size_t f_env_iterator_now_value(void *value_buf, size_t buf_len) ef_port_read(_g_env_iter_obj.env.addr.value, (uint32_t *) value_buf, _g_env_iter_obj.env.value_len); return 0; } - - + + } /** * @brief Get next blob ENV - * - * @param key ENV name buffer - * @param value_buf ENV blob buffer + * * @param value_len ENV blob buffer length - * @return char 1:Traversal complete 0:Traversal not complete + * @return char* 0:Traversal complete nonzero:ENV name */ -char ef_env_iterator_next() +char* ef_env_iterator_next(size_t *value_len) { uint32_t sec_addr; ef_port_env_lock(); @@ -1234,7 +1402,7 @@ _reload: if ((sec_addr = get_next_sector_addr(&_g_env_iter_obj.sector)) == FAILED_ADDR) { ef_port_env_unlock(); - return 1; + return 0; } if (read_sector_meta_data(sec_addr, &_g_env_iter_obj.sector, false) != EF_NO_ERR) { @@ -1252,8 +1420,13 @@ _next: if (_g_env_iter_obj.env.status == ENV_WRITE) { _g_env_iter_obj.env.name[_g_env_iter_obj.env.name_len] = 0; + + if(value_len) + { + *value_len = _g_env_iter_obj.env.value_len; + } ef_port_env_unlock(); - return 0; + return _g_env_iter_obj.env.name; } else { @@ -1281,7 +1454,8 @@ static bool gc_check_cb(sector_meta_data_t sector, void *arg1, void *arg2) { size_t *empty_sec = arg1; - if (sector->check_ok) { + if (sector->check_ok) + { *empty_sec = *empty_sec + 1; } @@ -1293,17 +1467,21 @@ static bool do_gc(sector_meta_data_t sector, void *arg1, void *arg2) { struct env_meta_data env; - if (sector->check_ok && (sector->status.dirty == SECTOR_DIRTY_TRUE || sector->status.dirty == SECTOR_DIRTY_GC)) { + if (sector->check_ok && (sector->status.dirty == SECTOR_DIRTY_TRUE || sector->status.dirty == SECTOR_DIRTY_GC)) + { uint8_t status_table[DIRTY_STATUS_TABLE_SIZE]; /* change the sector status to GC */ write_status(sector->addr + SECTOR_DIRTY_OFFSET, status_table, SECTOR_DIRTY_STATUS_NUM, SECTOR_DIRTY_GC); /* search all ENV */ env.addr.start = FAILED_ADDR; - while ((env.addr.start = get_next_env_addr(sector, &env)) != FAILED_ADDR) { + while ((env.addr.start = get_next_env_addr(sector, &env)) != FAILED_ADDR) + { read_env(&env); - if (env.crc_is_ok && (env.status == ENV_WRITE || env.status == ENV_PRE_DELETE)) { + if (env.crc_is_ok && (env.status == ENV_WRITE || env.status == ENV_PRE_DELETE)) + { /* move the ENV to new space */ - if (move_env(&env) != EF_NO_ERR) { + if (move_env(&env) != EF_NO_ERR) + { EF_DEBUG("Error: Moved the ENV (%.*s) for GC failed.\n", env.name_len, env.name); } } @@ -1330,7 +1508,8 @@ static void gc_collect(void) /* do GC collect */ EF_DEBUG("The remain empty sector is %d, GC threshold is %d.\n", empty_sec, EF_GC_EMPTY_SEC_THRESHOLD); - if (empty_sec <= EF_GC_EMPTY_SEC_THRESHOLD) { + if (empty_sec <= EF_GC_EMPTY_SEC_THRESHOLD) + { sector_iterator(§or, SECTOR_STORE_UNUSED, NULL, NULL, do_gc, false); } @@ -1355,7 +1534,8 @@ static EfErrCode align_write(uint32_t addr, const uint32_t *buf, size_t size) result = ef_port_write(addr, buf, EF_WG_ALIGN_DOWN(size)); align_remain = size - EF_WG_ALIGN_DOWN(size); - if (result == EF_NO_ERR && align_remain) { + if (result == EF_NO_ERR && align_remain) + { memcpy(align_data, (uint8_t *)buf + EF_WG_ALIGN_DOWN(size), align_remain); result = ef_port_write(addr + EF_WG_ALIGN_DOWN(size), (uint32_t *) align_data, align_data_size); } @@ -1370,7 +1550,8 @@ static EfErrCode create_env_blob(sector_meta_data_t sector, const char *key, con bool is_full = false; uint32_t env_addr = sector->empty_env; - if (strlen(key) > EF_ENV_NAME_MAX) { + if (strlen(key) > EF_ENV_NAME_MAX) + { EF_INFO("Error: The ENV name length is more than %d\n", EF_ENV_NAME_MAX); return EF_ENV_NAME_ERR; } @@ -1381,29 +1562,35 @@ static EfErrCode create_env_blob(sector_meta_data_t sector, const char *key, con env_hdr.value_len = len; env_hdr.len = ENV_HDR_DATA_SIZE + EF_WG_ALIGN(env_hdr.name_len) + EF_WG_ALIGN(env_hdr.value_len); - if (env_hdr.len > SECTOR_SIZE - SECTOR_HDR_DATA_SIZE) { + if (env_hdr.len > SECTOR_SIZE - SECTOR_HDR_DATA_SIZE) + { EF_INFO("Error: The ENV size is too big\n"); return EF_ENV_FULL; } - if (env_addr != FAILED_ADDR || (env_addr = new_env(sector, env_hdr.len)) != FAILED_ADDR) { + if (env_addr != FAILED_ADDR || (env_addr = new_env(sector, env_hdr.len)) != FAILED_ADDR) + { size_t align_remain; /* update the sector status */ - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { result = update_sec_status(sector, env_hdr.len, &is_full); } - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { uint8_t ff = 0xFF; /* start calculate CRC32 */ env_hdr.crc32 = ef_calc_crc32(0, &env_hdr.name_len, ENV_HDR_DATA_SIZE - ENV_NAME_LEN_OFFSET); env_hdr.crc32 = ef_calc_crc32(env_hdr.crc32, key, env_hdr.name_len); align_remain = EF_WG_ALIGN(env_hdr.name_len) - env_hdr.name_len; - while (align_remain--) { + while (align_remain--) + { env_hdr.crc32 = ef_calc_crc32(env_hdr.crc32, &ff, 1); } env_hdr.crc32 = ef_calc_crc32(env_hdr.crc32, value, env_hdr.value_len); align_remain = EF_WG_ALIGN(env_hdr.value_len) - env_hdr.value_len; - while (align_remain--) { + while (align_remain--) + { env_hdr.crc32 = ef_calc_crc32(env_hdr.crc32, &ff, 1); } /* write ENV header data */ @@ -1411,32 +1598,39 @@ static EfErrCode create_env_blob(sector_meta_data_t sector, const char *key, con } /* write key name */ - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { result = align_write(env_addr + ENV_HDR_DATA_SIZE, (uint32_t *) key, env_hdr.name_len); #ifdef EF_ENV_USING_CACHE - if (!is_full) { + if (!is_full) + { update_sector_cache(sector->addr, - env_addr + ENV_HDR_DATA_SIZE + EF_WG_ALIGN(env_hdr.name_len) + EF_WG_ALIGN(env_hdr.value_len)); + env_addr + ENV_HDR_DATA_SIZE + EF_WG_ALIGN(env_hdr.name_len) + EF_WG_ALIGN(env_hdr.value_len)); } update_env_cache(key, env_hdr.name_len, env_addr); #endif /* EF_ENV_USING_CACHE */ } /* write value */ - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { result = align_write(env_addr + ENV_HDR_DATA_SIZE + EF_WG_ALIGN(env_hdr.name_len), value, - env_hdr.value_len); + env_hdr.value_len); } /* change the ENV status to ENV_WRITE */ - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { result = write_status(env_addr, env_hdr.status_table, ENV_STATUS_NUM, ENV_WRITE); } /* trigger GC collect when current sector is full */ - if (result == EF_NO_ERR && is_full) { + if (result == EF_NO_ERR && is_full) + { EF_DEBUG("Trigger a GC check after created ENV.\n"); gc_request = true; } - } else { + } + else + { result = EF_ENV_FULL; } @@ -1454,7 +1648,8 @@ EfErrCode ef_del_env(const char *key) { EfErrCode result = EF_NO_ERR; - if (!init_ok) { + if (!init_ok) + { EF_INFO("Error: ENV isn't initialize OK.\n"); return EF_ENV_INIT_FAILED; } @@ -1492,28 +1687,36 @@ static EfErrCode set_env(const char *key, const void *value_buf, size_t buf_len) static struct sector_meta_data sector; bool env_is_found = false; - if (value_buf == NULL) { + if (value_buf == NULL) + { result = del_env(key, NULL, true); - } else { + } + else + { /* make sure the flash has enough space */ - if (new_env_by_kv(§or, strlen(key), buf_len) == FAILED_ADDR) { + if (new_env_by_kv(§or, strlen(key), buf_len) == FAILED_ADDR) + { return EF_ENV_FULL; } env_is_found = find_env(key, &env); /* prepare to delete the old ENV */ - if (env_is_found) { + if (env_is_found) + { result = del_env(key, &env, false); } /* create the new ENV */ - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { result = create_env_blob(§or, key, value_buf, buf_len); } /* delete the old ENV */ - if (env_is_found && result == EF_NO_ERR) { + if (env_is_found && result == EF_NO_ERR) + { result = del_env(key, &env, true); } /* process the GC after set ENV */ - if (gc_request) { + if (gc_request) + { gc_collect(); } } @@ -1536,7 +1739,8 @@ EfErrCode ef_set_env_blob(const char *key, const void *value_buf, size_t buf_len EfErrCode result = EF_NO_ERR; - if (!init_ok) { + if (!init_ok) + { EF_INFO("ENV isn't initialize OK.\n"); return EF_ENV_INIT_FAILED; } @@ -1610,24 +1814,31 @@ EfErrCode ef_env_set_default(void) /* lock the ENV cache */ ef_port_env_lock(); /* format all sectors */ - for (addr = env_start_addr; addr < env_start_addr + ENV_AREA_SIZE; addr += SECTOR_SIZE) { + for (addr = env_start_addr; addr < env_start_addr + ENV_AREA_SIZE; addr += SECTOR_SIZE) + { result = format_sector(addr, SECTOR_NOT_COMBINED); - if (result != EF_NO_ERR) { + if (result != EF_NO_ERR) + { goto __exit; } } /* create default ENV */ - for (i = 0; i < default_env_set_size; i++) { + for (i = 0; i < default_env_set_size; i++) + { /* It seems to be a string when value length is 0. * This mechanism is for compatibility with older versions (less then V4.0). */ - if (default_env_set[i].value_len == 0) { + if (default_env_set[i].value_len == 0) + { value_len = strlen(default_env_set[i].value); - } else { + } + else + { value_len = default_env_set[i].value_len; } sector.empty_env = FAILED_ADDR; create_env_blob(§or, default_env_set[i].key, default_env_set[i].value, value_len); - if (result != EF_NO_ERR) { + if (result != EF_NO_ERR) + { goto __exit; } } @@ -1644,39 +1855,54 @@ static bool print_env_cb(env_meta_data_t env, void *arg1, void *arg2) bool value_is_str = true, print_value = false; size_t *using_size = arg1; - if (env->crc_is_ok) { + if (env->crc_is_ok) + { /* calculate the total using flash size */ *using_size += env->len; /* check ENV */ - if (env->status == ENV_WRITE) { + if (env->status == ENV_WRITE) + { ef_print("%.*s=", env->name_len, env->name); - if (env->value_len < EF_STR_ENV_VALUE_MAX_SIZE ) { + if (env->value_len < EF_STR_ENV_VALUE_MAX_SIZE ) + { uint8_t buf[32]; size_t len, size; __reload: /* check the value is string */ - for (len = 0, size = 0; len < env->value_len; len += size) { - if (len + sizeof(buf) < env->value_len) { + for (len = 0, size = 0; len < env->value_len; len += size) + { + if (len + sizeof(buf) < env->value_len) + { size = sizeof(buf); - } else { + } + else + { size = env->value_len - len; } ef_port_read(env->addr.value + len, (uint32_t *) buf, EF_WG_ALIGN(size)); - if (print_value) { + if (print_value) + { ef_print("%.*s", size, buf); - } else if (!ef_is_str(buf, size)) { + } + else if (!ef_is_str(buf, size)) + { value_is_str = false; break; } } - } else { + } + else + { value_is_str = false; } - if (value_is_str && !print_value) { + if (value_is_str && !print_value) + { print_value = true; goto __reload; - } else if (!value_is_str) { + } + else if (!value_is_str) + { ef_print("blob @0x%08X %dbytes", env->addr.value, env->value_len); } ef_print("\n"); @@ -1695,7 +1921,8 @@ void ef_print_env(void) struct env_meta_data env; size_t using_size = 0; - if (!init_ok) { + if (!init_ok) + { EF_INFO("ENV isn't initialize OK.\n"); return; } @@ -1707,7 +1934,7 @@ void ef_print_env(void) ef_print("\nmode: next generation\n"); ef_print("size: %lu/%lu bytes.\n", using_size + (SECTOR_NUM - EF_GC_EMPTY_SEC_THRESHOLD) * SECTOR_HDR_DATA_SIZE, - ENV_AREA_SIZE - SECTOR_SIZE * EF_GC_EMPTY_SEC_THRESHOLD); + ENV_AREA_SIZE - SECTOR_SIZE * EF_GC_EMPTY_SEC_THRESHOLD); /* unlock the ENV cache */ ef_port_env_unlock(); @@ -1721,28 +1948,37 @@ static void env_auto_update(void) { size_t saved_ver_num, setting_ver_num = EF_ENV_VER_NUM; - if (get_env(VER_NUM_ENV_NAME, &saved_ver_num, sizeof(size_t), NULL) > 0) { + if (get_env(VER_NUM_ENV_NAME, &saved_ver_num, sizeof(size_t), NULL) > 0) + { /* check version number */ - if (saved_ver_num != setting_ver_num) { + if (saved_ver_num != setting_ver_num) + { struct env_meta_data env; size_t i, value_len; struct sector_meta_data sector; EF_DEBUG("Update the ENV from version %d to %d.\n", saved_ver_num, setting_ver_num); - for (i = 0; i < default_env_set_size; i++) { + for (i = 0; i < default_env_set_size; i++) + { /* add a new ENV when it's not found */ - if (!find_env(default_env_set[i].key, &env)) { + if (!find_env(default_env_set[i].key, &env)) + { /* It seems to be a string when value length is 0. * This mechanism is for compatibility with older versions (less then V4.0). */ - if (default_env_set[i].value_len == 0) { + if (default_env_set[i].value_len == 0) + { value_len = strlen(default_env_set[i].value); - } else { + } + else + { value_len = default_env_set[i].value_len; } sector.empty_env = FAILED_ADDR; create_env_blob(§or, default_env_set[i].key, default_env_set[i].value, value_len); } } - } else { + } + else + { /* version number not changed now return */ return; } @@ -1754,7 +1990,8 @@ static void env_auto_update(void) static bool check_sec_hdr_cb(sector_meta_data_t sector, void *arg1, void *arg2) { - if (!sector->check_ok) { + if (!sector->check_ok) + { size_t *failed_count = arg1; EF_INFO("Warning: Sector header check failed. Format this sector (0x%08x).\n", sector->addr); @@ -1767,7 +2004,8 @@ static bool check_sec_hdr_cb(sector_meta_data_t sector, void *arg1, void *arg2) static bool check_and_recovery_gc_cb(sector_meta_data_t sector, void *arg1, void *arg2) { - if (sector->check_ok && sector->status.dirty == SECTOR_DIRTY_GC) { + if (sector->check_ok && sector->status.dirty == SECTOR_DIRTY_GC) + { /* make sure the GC request flag to true */ gc_request = true; /* resume the GC operate */ @@ -1780,16 +2018,22 @@ static bool check_and_recovery_gc_cb(sector_meta_data_t sector, void *arg1, void static bool check_and_recovery_env_cb(env_meta_data_t env, void *arg1, void *arg2) { /* recovery the prepare deleted ENV */ - if (env->crc_is_ok && env->status == ENV_PRE_DELETE) { + if (env->crc_is_ok && env->status == ENV_PRE_DELETE) + { EF_INFO("Found an ENV (%.*s) which has changed value failed. Now will recovery it.\n", env->name_len, env->name); /* recovery the old ENV */ - if (move_env(env) == EF_NO_ERR) { + if (move_env(env) == EF_NO_ERR) + { EF_DEBUG("Recovery the ENV successful.\n"); - } else { + } + else + { EF_DEBUG("Warning: Moved an ENV (size %d) failed when recovery. Now will GC then retry.\n", env->len); return true; } - } else if (env->status == ENV_PRE_WRITE) { + } + else if (env->status == ENV_PRE_WRITE) + { uint8_t status_table[ENV_STATUS_TABLE_SIZE]; /* the ENV has not write finish, change the status to error */ //TODO 绘制异常处理的状态装换图 @@ -1816,11 +2060,12 @@ EfErrCode ef_load_env(void) /* check all sector header */ sector_iterator(§or, SECTOR_STORE_UNUSED, &check_failed_count, NULL, check_sec_hdr_cb, false); /* all sector header check failed */ - if (check_failed_count == SECTOR_NUM) { + if (check_failed_count == SECTOR_NUM) + { EF_INFO("Warning: All sector header check failed. Set it to default.\n"); ef_env_set_default(); } - + /* lock the ENV cache */ ef_port_env_lock(); /* check all sector header for recovery GC */ @@ -1829,7 +2074,8 @@ EfErrCode ef_load_env(void) __retry: /* check all ENV for recovery */ env_iterator(&env, NULL, NULL, check_and_recovery_env_cb); - if (gc_request) { + if (gc_request) + { gc_collect(); goto __retry; } @@ -1850,7 +2096,8 @@ __retry: * * @return result */ -EfErrCode ef_env_init(ef_env const *default_env, size_t default_env_size) { +EfErrCode ef_env_init(ef_env const *default_env, size_t default_env_size) +{ EfErrCode result = EF_NO_ERR; #ifdef EF_ENV_USING_CACHE @@ -1866,15 +2113,18 @@ EfErrCode ef_env_init(ef_env const *default_env, size_t default_env_size) { /* must be aligned with write granularity */ EF_ASSERT((EF_STR_ENV_VALUE_MAX_SIZE * 8) % EF_WRITE_GRAN == 0); - if (init_ok) { + if (init_ok) + { return EF_NO_ERR; } #ifdef EF_ENV_USING_CACHE - for (i = 0; i < EF_SECTOR_CACHE_TABLE_SIZE; i++) { + for (i = 0; i < EF_SECTOR_CACHE_TABLE_SIZE; i++) + { sector_cache_table[i].addr = FAILED_ADDR; } - for (i = 0; i < EF_ENV_CACHE_TABLE_SIZE; i++) { + for (i = 0; i < EF_ENV_CACHE_TABLE_SIZE; i++) + { env_cache_table[i].addr = FAILED_ADDR; } #endif /* EF_ENV_USING_CACHE */ @@ -1888,12 +2138,14 @@ EfErrCode ef_env_init(ef_env const *default_env, size_t default_env_size) { result = ef_load_env(); #ifdef EF_ENV_AUTO_UPDATE - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { env_auto_update(); } #endif - if (result == EF_NO_ERR) { + if (result == EF_NO_ERR) + { init_ok = true; } From 7877c43aa92dc6be3da803751e68daf74fdf37a9 Mon Sep 17 00:00:00 2001 From: brand Date: Tue, 14 Jan 2020 11:54:27 +0800 Subject: [PATCH 4/4] =?UTF-8?q?=E9=85=8D=E5=90=88=E6=9C=80=E6=96=B0?= =?UTF-8?q?=E5=88=86=E6=94=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- easyflash/inc/easyflash.h | 2 +- easyflash/src/ef_env.c | 7 +------ 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/easyflash/inc/easyflash.h b/easyflash/inc/easyflash.h index 1c3a214..365d186 100644 --- a/easyflash/inc/easyflash.h +++ b/easyflash/inc/easyflash.h @@ -66,7 +66,7 @@ void ef_env_iterator_to_first(void); char *ef_env_iterator_now_name(void); size_t ef_env_iterator_now_value_len(void); size_t ef_env_iterator_now_value(void *value_buf, size_t buf_len); -env_node_obj_t ef_env_iterator_next(size_t *value_len); +env_node_obj_t ef_env_iterator_next(void); #endif #ifdef EF_USING_IAP diff --git a/easyflash/src/ef_env.c b/easyflash/src/ef_env.c index 1295a8d..03e43ff 100644 --- a/easyflash/src/ef_env.c +++ b/easyflash/src/ef_env.c @@ -1419,8 +1419,7 @@ size_t f_env_iterator_now_value(void *value_buf, size_t buf_len) * @param value_len ENV blob buffer length * @return char* 0:Traversal complete nonzero:ENV */ -env_node_obj_t ef_env_iterator_next(size_t *value_len) -//char* ef_env_iterator_next(size_t *value_len) +env_node_obj_t ef_env_iterator_next() { uint32_t sec_addr; ef_port_env_lock(); @@ -1449,10 +1448,6 @@ _next: { _g_env_iter_obj.env.name[_g_env_iter_obj.env.name_len] = 0; - if(value_len) - { - *value_len = _g_env_iter_obj.env.value_len; - } ef_port_env_unlock(); return &_g_env_iter_obj.env; }