/*
* This file is part of the EasyFlash Library.
*
* Copyright (c) 2019, Armink, <armink.ztl@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* 'Software'), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Function: Environment variables operating interface. This is the Next Generation version.
* Created on: 2019-02-02
*/
#include <string.h>
#include <easyflash.h>
#if defined(EF_USING_ENV) && !defined(EF_ENV_USING_LEGACY_MODE)
#ifndef EF_WRITE_GRAN
#error "Please configure flash write granularity (in ef_cfg.h)"
#endif
#if EF_WRITE_GRAN != 1 && EF_WRITE_GRAN != 8 && EF_WRITE_GRAN != 32 && EF_WRITE_GRAN != 64
#error "the write gran can be only setting as 1, 8, 32 and 64"
#endif
/* magic word(`E`, `F`, `4`, `0`) */
#define SECTOR_MAGIC_WORD 0x30344645
/* magic word(`K`, `V`, `4`, `0`) */
#define ENV_MAGIC_WORD 0x3034564B
/* the using status sector table length */
#ifndef USING_SECTOR_TABLE_LEN
#define USING_SECTOR_TABLE_LEN 4
#endif
/* the string ENV value buffer size for legacy ef_get_env() function */
#ifndef EF_STR_ENV_VALUE_MAX_SIZE
#define EF_STR_ENV_VALUE_MAX_SIZE 128
#endif
/* the sector remain threshold before full status */
#ifndef EF_SEC_REMAIN_THRESHOLD
#define EF_SEC_REMAIN_THRESHOLD (ENV_HDR_DATA_SIZE + EF_ENV_NAME_MAX)
#endif
/* the total remain empty sector threshold before GC */
#ifndef EF_GC_EMPTY_SEC_THRESHOLD
#define EF_GC_EMPTY_SEC_THRESHOLD 1
#endif
/* the ENV cache table size, it will improve ENV search speed when using cache */
#ifndef EF_ENV_CACHE_TABLE_SIZE
#define EF_ENV_CACHE_TABLE_SIZE 16
#endif
/* the sector cache table size, it will improve ENV save speed when using cache */
#ifndef EF_SECTOR_CACHE_TABLE_SIZE
#define EF_SECTOR_CACHE_TABLE_SIZE 4
#endif
#if EF_ENV_CACHE_TABLE_SIZE > 0xFFFF
#error "The ENV cache table size must less than 0xFFFF"
#endif
#if (EF_ENV_CACHE_TABLE_SIZE > 0) && (EF_SECTOR_CACHE_TABLE_SIZE > 0)
#define EF_ENV_USING_CACHE
#endif
/* the sector is not combined value */
#define SECTOR_NOT_COMBINED 0xFFFFFFFF
/* the next address is get failed */
#define FAILED_ADDR 0xFFFFFFFF
/* Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4)
* would return 16.
*/
#define EF_ALIGN(size, align) (((size) + (align) - 1) & ~((align) - 1))
/* align by write granularity */
#define EF_WG_ALIGN(size) (EF_ALIGN(size, (EF_WRITE_GRAN + 7)/8))
/**
* Return the down number of aligned at specified width. RT_ALIGN_DOWN(13, 4)
* would return 12.
*/
#define EF_ALIGN_DOWN(size, align) ((size) & ~((align) - 1))
/* align down by write granularity */
#define EF_WG_ALIGN_DOWN(size) (EF_ALIGN_DOWN(size, (EF_WRITE_GRAN + 7)/8))
#if (EF_WRITE_GRAN == 1)
#define STATUS_TABLE_SIZE(status_number) ((status_number * EF_WRITE_GRAN + 7)/8)
#else
#define STATUS_TABLE_SIZE(status_number) (((status_number - 1) * EF_WRITE_GRAN + 7)/8)
#endif
#define STORE_STATUS_TABLE_SIZE STATUS_TABLE_SIZE(SECTOR_STORE_STATUS_NUM)
#define DIRTY_STATUS_TABLE_SIZE STATUS_TABLE_SIZE(SECTOR_DIRTY_STATUS_NUM)
#define ENV_STATUS_TABLE_SIZE STATUS_TABLE_SIZE(ENV_STATUS_NUM)
#define SECTOR_SIZE EF_ERASE_MIN_SIZE
#define SECTOR_NUM (ENV_AREA_SIZE / (EF_ERASE_MIN_SIZE))
#if (SECTOR_NUM < 2)
#error "The sector number must lager then or equal to 2"
#endif
#if (EF_GC_EMPTY_SEC_THRESHOLD == 0 || EF_GC_EMPTY_SEC_THRESHOLD >= SECTOR_NUM)
#error "There is at least one empty sector for GC."
#endif
#define SECTOR_HDR_DATA_SIZE (EF_WG_ALIGN(sizeof(struct sector_hdr_data)))
#define SECTOR_DIRTY_OFFSET ((unsigned long)(&((struct sector_hdr_data *)0)->status_table.dirty))
#define ENV_HDR_DATA_SIZE (EF_WG_ALIGN(sizeof(struct env_hdr_data)))
#define ENV_MAGIC_OFFSET ((unsigned long)(&((struct env_hdr_data *)0)->magic))
#define ENV_LEN_OFFSET ((unsigned long)(&((struct env_hdr_data *)0)->len))
#define ENV_NAME_LEN_OFFSET ((unsigned long)(&((struct env_hdr_data *)0)->name_len))
#define VER_NUM_ENV_NAME "__ver_num__"
enum sector_store_status {
SECTOR_STORE_UNUSED,
SECTOR_STORE_EMPTY,
SECTOR_STORE_USING,
SECTOR_STORE_FULL,
SECTOR_STORE_STATUS_NUM,
};
typedef enum sector_store_status sector_store_status_t;
enum sector_dirty_status {
SECTOR_DIRTY_UNUSED,
SECTOR_DIRTY_FALSE,
SECTOR_DIRTY_TRUE,
SECTOR_DIRTY_GC,
SECTOR_DIRTY_STATUS_NUM,
};
typedef enum sector_dirty_status sector_dirty_status_t;
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;
uint32_t magic; /**< magic word(`E`, `F`, `4`, `0`) */
uint32_t combined; /**< the combined next sector number, 0xFFFFFFFF: not combined */
uint32_t reserved;
};
typedef struct sector_hdr_data *sector_hdr_data_t;
struct sector_meta_data {
bool check_ok; /**< sector header check is OK */
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;
uint32_t addr; /**< sector start address */
uint32_t magic; /**< magic word(`E`, `F`, `4`, `0`) */
uint32_t combined; /**< the combined next sector number, 0xFFFFFFFF: not combined */
size_t remain; /**< remain size */
uint32_t empty_env; /**< the next empty ENV node start address */
};
typedef struct sector_meta_data *sector_meta_data_t;
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 */
uint32_t crc32; /**< ENV node crc32(name_len + data_len + name + value) */
uint8_t name_len; /**< name length */
uint32_t value_len; /**< value length */
};
typedef struct env_hdr_data *env_hdr_data_t;
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 {
uint32_t addr; /**< sector start address */
uint32_t empty_addr; /**< sector empty address */
};
typedef struct sector_cache_node *sector_cache_node_t;
static void gc_collect(void);
/* ENV start address in flash */
static uint32_t env_start_addr = 0;
/* default ENV set, must be initialized by user */
static ef_env const *default_env_set;
/* default ENV set size, must be initialized by user */
static size_t default_env_set_size = 0;
/* initialize OK flag */
static bool init_ok = false;
/* request a GC check */
static bool gc_request = false;
/* is in recovery check status when first reboot */
static bool in_recovery_check = false;
#ifdef EF_ENV_USING_CACHE
/* ENV cache table */
struct env_cache_node env_cache_table[EF_ENV_CACHE_TABLE_SIZE] = { 0 };
/* sector cache table, it caching the sector info which status is current using */
struct sector_cache_node sector_cache_table[EF_SECTOR_CACHE_TABLE_SIZE] = { 0 };
#endif /* EF_ENV_USING_CACHE */
static size_t set_status(uint8_t status_table[], size_t status_num, size_t status_index)
{
size_t byte_index = ~0UL;
/*
* | write garn | status0 | status1 | status2 |
* ---------------------------------------------------------------------------------
* | 1bit | 0xFF | 0x7F | 0x3F |
* | 8bit | 0xFFFF | 0x00FF | 0x0000 |
* | 32bit | 0xFFFFFFFF FFFFFFFF | 0x00FFFFFF FFFFFFFF | 0x00FFFFFF 00FFFFFF |
*/
memset(status_table, 0xFF, STATUS_TABLE_SIZE(status_num));
if (status_index > 0) {
#if (EF_WRITE_GRAN == 1)
byte_index = (status_index - 1) / 8;
status_table[byte_index] &= ~(0x80 >> ((status_index - 1) % 8));
#else
byte_index = (status_index - 1) * (EF_WRITE_GRAN / 8);
status_table[byte_index] = 0x00;
#endif /* EF_WRITE_GRAN == 1 */
}
return byte_index;
}
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 --) {
/* 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) {
break;
}
#else /* (EF_WRITE_GRAN == 8) || (EF_WRITE_GRAN == 32) || (EF_WRITE_GRAN == 64) */
if (status_table[status_num * EF_WRITE_GRAN / 8] == 0x00) {
break;
}
#endif /* EF_WRITE_GRAN == 1 */
i++;
}
return status_num_bak - i;
}
static EfErrCode write_status(uint32_t addr, uint8_t status_table[], size_t status_num, size_t status_index)
{
EfErrCode result = EF_NO_ERR;
size_t byte_index;
EF_ASSERT(status_index < status_num);
EF_ASSERT(status_table);
/* set the status first */
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) {
return EF_NO_ERR;
}
#if (EF_WRITE_GRAN == 1)
result = ef_port_write(addr + byte_index, (uint32_t *)&status_table[byte_index], 1);
#else /* (EF_WRITE_GRAN == 8) || (EF_WRITE_GRAN == 32) || (EF_WRITE_GRAN == 64) */
/* write the status by write granularity
* some flash (like stm32 onchip) NOT supported repeated write before erase */
result = ef_port_write(addr + byte_index, (uint32_t *) &status_table[byte_index], EF_WRITE_GRAN / 8);
#endif /* EF_WRITE_GRAN == 1 */
return result;
}
static size_t read_status(uint32_t addr, uint8_t status_table[], size_t total_num)
{
EF_ASSERT(status_table);
ef_port_read(addr, (uint32_t *) status_table, STATUS_TABLE_SIZE(total_num));
return get_status(status_table, total_num);
}
#ifdef EF_ENV_USING_CACHE
/*
* It's only caching the current using status sector's empty_addr
*/
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)) {
/* update the sector empty_addr in cache */
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)) {
empty_index = i;
}
} 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) {
sector_cache_table[empty_index].addr = sec_addr;
sector_cache_table[empty_index].empty_addr = empty_addr;
}
}
/*
* Get sector info from cache. It's return true when cache is hit.
*/
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) {
*empty_addr = sector_cache_table[i].empty_addr;
}
return true;
}
}
return false;
}
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) {
/* update the ENV address in cache */
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)) {
empty_index = i;
} 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) {
min_activity_index = i;
min_activity = env_cache_table[i].active;
}
}
} 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;
return;
}
}
/* add the ENV to cache, using LRU (Least Recently Used) like algorithm */
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) {
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;
}
}
/*
* Get ENV info from cache. It's return true when cache is hit.
*/
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)) {
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)) {
*addr = env_cache_table[i].addr;
if (env_cache_table[i].active >= 0xFFFF - EF_ENV_CACHE_TABLE_SIZE) {
env_cache_table[i].active = 0xFFFF;
} else {
env_cache_table[i].active += EF_ENV_CACHE_TABLE_SIZE;
}
return true;
}
}
}
return false;
}
#endif /* EF_ENV_USING_CACHE */
/*
* find the continue 0xFF flash address to end address
*/
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) {
read_size = sizeof(buf);
} 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) {
addr = start + i;
}
last_data = buf[i];
}
}
if (last_data == 0xFF) {
return EF_WG_ALIGN(addr);
} else {
return end;
}
}
/*
* find the next ENV address by magic word on the flash
*/
static uint32_t find_next_env_addr(uint32_t start, uint32_t end)
{
uint8_t buf[32];
uint32_t start_bak = start, i;
uint32_t magic;
#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) {
return FAILED_ADDR;
}
#endif /* EF_ENV_USING_CACHE */
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++) {
#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) {
return start + i - ENV_MAGIC_OFFSET;
}
}
}
return FAILED_ADDR;
}
static uint32_t get_next_env_addr(sector_meta_data_t sector, env_node_obj_t pre_env)
{
uint32_t addr = FAILED_ADDR;
if (sector->status.store == SECTOR_STORE_EMPTY) {
return 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) {
addr = pre_env->addr.start + pre_env->len;
} 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);
}
/* 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) {
//TODO ��������ģʽ
return FAILED_ADDR;
}
} else {
/* no ENV */
return FAILED_ADDR;
}
}
return addr;
}
static EfErrCode read_env(env_node_obj_t env)
{
struct env_hdr_data env_hdr;
uint8_t buf[32];
uint32_t calc_crc32 = 0, crc_data_len, env_name_addr;
EfErrCode result = EF_NO_ERR;
size_t len, size;
/* read ENV header raw data */
ef_port_read(env->addr.start, (uint32_t *)&env_hdr, sizeof(struct env_hdr_data));
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) {
/* 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) {
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) {
//TODO ��������ģʽ������д�볤��û��д������
EF_ASSERT(0);
}
/* 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) {
size = sizeof(buf);
} else {
size = crc_data_len - len;
}
ef_port_read(env->addr.start + ENV_NAME_LEN_OFFSET + len, (uint32_t *) buf, EF_WG_ALIGN(size));
calc_crc32 = ef_calc_crc32(calc_crc32, buf, size);
}
/* check CRC32 */
if (calc_crc32 != env_hdr.crc32) {
env->crc_is_ok = false;
result = EF_READ_ERR;
} else {
env->crc_is_ok = true;
/* the name is behind aligned ENV header */
env_name_addr = env->addr.start + ENV_HDR_DATA_SIZE;
ef_port_read(env_name_addr, (uint32_t *) env->name, EF_WG_ALIGN(env_hdr.name_len));
/* the value is behind aligned name */
env->addr.value = env_name_addr + EF_WG_ALIGN(env_hdr.name_len);
env->value_len = env_hdr.value_len;
env->name_len = env_hdr.name_len;
}
return result;
}
static EfErrCode read_sector_meta_data(uint32_t addr, sector_meta_data_t sector, bool traversal)
{
EfErrCode result = EF_NO_ERR;
struct sector_hdr_data sec_hdr;
EF_ASSERT(addr % SECTOR_SIZE == 0);
EF_ASSERT(sector);
/* read sector header raw data */
ef_port_read(addr, (uint32_t *)&sec_hdr, sizeof(struct sector_hdr_data));
sector->addr = addr;
sector->magic = sec_hdr.magic;
/* check magic word */
if (sector->magic != SECTOR_MAGIC_WORD) {
sector->check_ok = false;
sector->combined = SECTOR_NOT_COMBINED;
return EF_ENV_INIT_FAILED;
}
sector->check_ok = true;
/* get other sector meta data */
sector->combined = sec_hdr.combined;
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) {
sector->remain = 0;
sector->empty_env = sector->addr + SECTOR_HDR_DATA_SIZE;
if (sector->status.store == SECTOR_STORE_EMPTY) {
sector->remain = SECTOR_SIZE - SECTOR_HDR_DATA_SIZE;
} else if (sector->status.store == SECTOR_STORE_USING) {
struct env_node_obj env_meta;
#ifdef EF_ENV_USING_CACHE
if (get_sector_from_cache(addr, §or->empty_env)) {
sector->remain = SECTOR_SIZE - (sector->empty_env - sector->addr);
return result;
}
#endif /* EF_ENV_USING_CACHE */
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) {
read_env(&env_meta);
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;
break;
}
}
sector->empty_env += env_meta.len;
sector->remain -= env_meta.len;
}
/* check the empty ENV address by read continue 0xFF on flash */
{
uint32_t ff_addr;
ff_addr = continue_ff_addr(sector->empty_env, sector->addr + SECTOR_SIZE);
/* check the flash data is clean */
if (sector->empty_env != ff_addr) {
/* update the sector information */
sector->empty_env = ff_addr;
sector->remain = SECTOR_SIZE - (ff_addr - sector->addr);
}
}
#ifdef EF_ENV_USING_CACHE
update_sector_cache(sector->addr, sector->empty_env);
#endif
}
}
return result;
}
static uint32_t get_next_sector_addr(sector_meta_data_t pre_sec)
{
uint32_t next_addr;
if (pre_sec->addr == FAILED_ADDR) {
return env_start_addr;
} else {
/* check ENV sector combined */
if (pre_sec->combined == SECTOR_NOT_COMBINED) {
next_addr = pre_sec->addr + SECTOR_SIZE;
} else {
next_addr = pre_sec->addr + pre_sec->combined * SECTOR_SIZE;
}
/* check range */
if (next_addr < env_start_addr + ENV_AREA_SIZE) {
return next_addr;
} else {
/* no sector */
return FAILED_ADDR;
}
}
}
static void env_iterator(env_node_obj_t env, void *arg1, void *arg2,
bool (*callback)(env_node_obj_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) {
continue;
}
if (callback == NULL) {
continue;
}
/* sector has ENV */
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) {
read_env(env);
/* iterator is interrupted when callback return true */
if (callback(env, arg1, arg2)) {
return;
}
}
}
}
}
static bool find_env_cb(env_node_obj_t env, void *arg1, void *arg2)
{
const char *key = arg1;
bool *find_ok = arg2;
size_t key_len = strlen(key);
if (key_len != env->name_len) {
return false;
}
/* check ENV */
if (env->crc_is_ok && env->status == ENV_WRITE && !strncmp(env->name, key, key_len)) {
*find_ok = true;
return true;
}
return false;
}
static bool find_env_no_cache(const char *key, env_node_obj_t env)
{
bool find_ok = false;
env_iterator(env, (void *)key, &find_ok, find_env_cb);
return find_ok;
}
static bool find_env(const char *key, env_node_obj_t env)
{
bool find_ok = false;
#ifdef EF_ENV_USING_CACHE
size_t key_len = strlen(key);
if (get_env_from_cache(key, key_len, &env->addr.start)) {
read_env(env);
return true;
}
#endif /* EF_ENV_USING_CACHE */
find_ok = find_env_no_cache(key, env);
#ifdef EF_ENV_USING_CACHE
if (find_ok) {
update_env_cache(key, key_len, env->addr.start);
}
#endif /* EF_ENV_USING_CACHE */
return find_ok;
}
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])) {
return false;
}
}
return true;
}
static size_t get_env(const char *key, void *value_buf, size_t buf_len, size_t *value_len)
{
struct env_node_obj env;
size_t read_len = 0;
if (find_env(key, &env)) {
if (value_len) {
*value_len = env.value_len;
}
if (buf_len > env.value_len) {
read_len = env.value_len;
} else {
read_len = buf_len;
}
if (value_buf){
ef_port_read(env.addr.value, (uint32_t *) value_buf, read_len);
}
} else if (value_len) {
*value_len = 0;
}
return read_len;
}
/**
* Get a ENV object by key name
*
* @param key ENV name
* @param env ENV object
*
* @return TRUE: find the ENV is OK, else return false
*/
bool ef_get_env_obj(const char *key, env_node_obj_t env)
{
bool find_ok = false;
if (!init_ok) {
EF_INFO("ENV isn't initialize OK.\n");
return 0;
}
/* lock the ENV cache */
ef_port_env_lock();
find_ok = find_env(key, env);
/* unlock the ENV cache */
ef_port_env_unlock();
return find_ok;
}
/**
* Get a blob ENV value by key name.
*
* @param key ENV name
* @param value_buf ENV blob buffer
* @param buf_len ENV blob buffer length
* @param saved_value_len return the length of the value saved on the flash, 0: NOT found
*
* @return the actually get size on successful
*/
size_t ef_get_env_blob(const char *key, void *value_buf, size_t buf_len, size_t *saved_value_len)
{
size_t read_len = 0;
if (!init_ok) {
EF_INFO("ENV isn't initialize OK.\n");
return 0;
}
/* lock the ENV cache */
ef_port_env_lock();
read_len = get_env(key, value_buf, buf_len, saved_value_len);
/* unlock the ENV cache */
ef_port_env_unlock();
return read_len;
}
/**
* Get an ENV value by key name.
*
* @note this function is NOT supported reentrant
* @note this function is DEPRECATED
*
* @param key ENV name
*
* @return value
*/
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) {
/* the return value must be string */
if (ef_is_str((uint8_t *)value, get_size)) {
value[get_size] = '\0';
return value;
} else {
EF_INFO("Warning: The ENV value isn't string. Could not be returned\n");
return NULL;
}
}
return NULL;
}
/**
* read the ENV value by ENV object
*
* @param env ENV object
* @param value_buf the buffer for store ENV value
* @param buf_len buffer length
*
* @return the actually read size on successful
*/
size_t ef_read_env_value(env_node_obj_t env, uint8_t *value_buf, size_t buf_len)
{
size_t read_len = 0;
EF_ASSERT(env);
EF_ASSERT(value_buf);
if (!init_ok) {
EF_INFO("ENV isn't initialize OK.\n");
return 0;
}
if (env->crc_is_ok) {
/* lock the ENV cache */
ef_port_env_lock();
if (buf_len > env->value_len) {
read_len = env->value_len;
} else {
read_len = buf_len;
}
ef_port_read(env->addr.value, (uint32_t *) value_buf, read_len);
/* unlock the ENV cache */
ef_port_env_unlock();
}
return read_len;
}
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) {
return result;
}
/* write other header data */
result = ef_port_write(addr + ENV_MAGIC_OFFSET, &env_hdr->magic, sizeof(struct env_hdr_data) - ENV_MAGIC_OFFSET);
return result;
}
static EfErrCode format_sector(uint32_t addr, uint32_t combined_value)
{
EfErrCode result = EF_NO_ERR;
struct sector_hdr_data sec_hdr;
EF_ASSERT(addr % SECTOR_SIZE == 0);
result = ef_port_erase(addr, SECTOR_SIZE);
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);
set_status(sec_hdr.status_table.dirty, SECTOR_DIRTY_STATUS_NUM, SECTOR_DIRTY_FALSE);
sec_hdr.magic = SECTOR_MAGIC_WORD;
sec_hdr.combined = combined_value;
sec_hdr.reserved = 0xFFFFFFFF;
/* save the header */
result = ef_port_write(addr, (uint32_t *)&sec_hdr, sizeof(struct sector_hdr_data));
#ifdef EF_ENV_USING_CACHE
/* delete the sector cache */
update_sector_cache(addr, addr + SECTOR_SIZE);
#endif /* EF_ENV_USING_CACHE */
}
return result;
}
static EfErrCode update_sec_status(sector_meta_data_t sector, size_t new_env_len, bool *is_full)
{
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) {
/* 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) {
/* check remain size */
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);
#ifdef EF_ENV_USING_CACHE
/* delete the sector cache */
update_sector_cache(sector->addr, sector->addr + SECTOR_SIZE);
#endif /* EF_ENV_USING_CACHE */
if (is_full) {
*is_full = true;
}
} else if (is_full) {
*is_full = false;
}
}
return result;
}
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) {
uint32_t sec_addr;
/* search all sectors */
sector->addr = 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) {
read_sector_meta_data(sec_addr, sector, traversal_env);
}
/* iterator is interrupted when callback return true */
if (callback && callback(sector, arg1, arg2)) {
return;
}
}
}
}
static bool sector_statistics_cb(sector_meta_data_t sector, void *arg1, void *arg2)
{
size_t *empty_sector = arg1, *using_sector = arg2;
if (sector->check_ok && sector->status.store == SECTOR_STORE_EMPTY) {
(*empty_sector)++;
} else if (sector->check_ok && sector->status.store == SECTOR_STORE_USING) {
(*using_sector)++;
}
return false;
}
static bool alloc_env_cb(sector_meta_data_t sector, void *arg1, void *arg2)
{
size_t *env_size = arg1;
uint32_t *empty_env = arg2;
/* 1. sector has space
* 2. the NO dirty sector
* 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))) {
*empty_env = sector->empty_env;
return true;
}
return false;
}
static uint32_t alloc_env(sector_meta_data_t sector, size_t env_size)
{
uint32_t empty_env = FAILED_ADDR;
size_t empty_sector = 0, using_sector = 0;
/* sector status statistics */
sector_iterator(sector, SECTOR_STORE_UNUSED, &empty_sector, &using_sector, sector_statistics_cb, false);
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) {
sector_iterator(sector, SECTOR_STORE_EMPTY, &env_size, &empty_env, alloc_env_cb, true);
} 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;
}
}
return empty_env;
}
static EfErrCode del_env(const char *key, env_node_obj_t old_env, bool complete_del) {
EfErrCode result = EF_NO_ERR;
uint32_t dirty_status_addr;
static bool last_is_complete_del = false;
#if (ENV_STATUS_TABLE_SIZE >= DIRTY_STATUS_TABLE_SIZE)
uint8_t status_table[ENV_STATUS_TABLE_SIZE];
#else
uint8_t status_table[DIRTY_STATUS_TABLE_SIZE];
#endif
/* need find ENV */
if (!old_env) {
struct env_node_obj env;
/* find ENV */
if (find_env(key, &env)) {
old_env = &env;
} else {
EF_DEBUG("Not found '%s' in ENV.\n", key);
return EF_ENV_NAME_ERR;
}
}
/* change and save the new status */
if (!complete_del) {
result = write_status(old_env->addr.start, status_table, ENV_STATUS_NUM, ENV_PRE_DELETE);
last_is_complete_del = true;
} else {
result = write_status(old_env->addr.start, status_table, ENV_STATUS_NUM, ENV_DELETED);
if (!last_is_complete_del && result == EF_NO_ERR) {
#ifdef EF_ENV_USING_CACHE
/* delete the ENV in flash and cache */
if (key != NULL) {
/* when using del_env(key, NULL, true) or del_env(key, env, true) in ef_del_env() and set_env() */
update_env_cache(key, strlen(key), FAILED_ADDR);
} else if (old_env != NULL) {
/* when using del_env(NULL, env, true) in move_env() */
update_env_cache(old_env->name, old_env->name_len, FAILED_ADDR);
}
#endif /* EF_ENV_USING_CACHE */
}
last_is_complete_del = false;
}
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) {
result = write_status(dirty_status_addr, status_table, SECTOR_DIRTY_STATUS_NUM, SECTOR_DIRTY_TRUE);
}
return result;
}
/*
* move the ENV to new space
*/
static EfErrCode move_env(env_node_obj_t env)
{
EfErrCode result = EF_NO_ERR;
uint8_t status_table[ENV_STATUS_TABLE_SIZE];
uint32_t env_addr;
struct sector_meta_data sector;
/* prepare to delete the current ENV */
if (env->status == ENV_WRITE) {
del_env(NULL, env, false);
}
if ((env_addr = alloc_env(§or, env->len)) != FAILED_ADDR) {
if (in_recovery_check) {
struct env_node_obj 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)) {
/* already create success, don't need to duplicate */
result = EF_NO_ERR;
goto __exit;
}
}
} else {
return EF_ENV_FULL;
}
/* start move the ENV */
{
uint8_t buf[32];
size_t len, size, env_len = env->len;
/* update the new ENV sector status first */
update_sec_status(§or, env->len, NULL);
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) {
size = sizeof(buf);
} else {
size = env_len - len;
}
ef_port_read(env->addr.start + ENV_MAGIC_OFFSET + len, (uint32_t *) buf, EF_WG_ALIGN(size));
result = ef_port_write(env_addr + ENV_MAGIC_OFFSET + len, (uint32_t *) buf, size);
}
write_status(env_addr, status_table, ENV_STATUS_NUM, ENV_WRITE);
#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));
update_env_cache(env->name, env->name_len, env_addr);
#endif /* EF_ENV_USING_CACHE */
}
EF_DEBUG("Moved the ENV (%.*s) from 0x%08X to 0x%08X.\n", env->name_len, env->name, env->addr.start, env_addr);
__exit:
del_env(NULL, env, true);
return result;
}
static uint32_t new_env(sector_meta_data_t sector, size_t env_size)
{
bool already_gc = false;
uint32_t empty_env = FAILED_ADDR;
__retry:
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;
goto __retry;
}
return empty_env;
}
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);
return new_env(sector, env_len);
}
static bool gc_check_cb(sector_meta_data_t sector, void *arg1, void *arg2)
{
size_t *empty_sec = arg1;
if (sector->check_ok) {
*empty_sec = *empty_sec + 1;
}
return false;
}
static bool do_gc(sector_meta_data_t sector, void *arg1, void *arg2)
{
struct env_node_obj env;
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) {
read_env(&env);
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) {
EF_DEBUG("Error: Moved the ENV (%.*s) for GC failed.\n", env.name_len, env.name);
}
}
}
format_sector(sector->addr, SECTOR_NOT_COMBINED);
EF_DEBUG("Collect a sector @0x%08X\n", sector->addr);
}
return false;
}
/*
* The GC will be triggered on the following scene:
* 1. alloc an ENV when the flash not has enough space
* 2. write an ENV then the flash not has enough space
*/
static void gc_collect(void)
{
struct sector_meta_data sector;
size_t empty_sec = 0;
/* GC check the empty sector number */
sector_iterator(§or, SECTOR_STORE_EMPTY, &empty_sec, NULL, gc_check_cb, false);
/* 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) {
sector_iterator(§or, SECTOR_STORE_UNUSED, NULL, NULL, do_gc, false);
}
gc_request = false;
}
static EfErrCode align_write(uint32_t addr, const uint32_t *buf, size_t size)
{
EfErrCode result = EF_NO_ERR;
size_t align_remain;
#if (EF_WRITE_GRAN / 8 > 0)
uint8_t align_data[EF_WRITE_GRAN / 8];
size_t align_data_size = sizeof(align_data);
#else
/* For compatibility with C89 */
uint8_t align_data_u8, *align_data = &align_data_u8;
size_t align_data_size = 1;
#endif
memset(align_data, 0xFF, align_data_size);
align_remain = EF_WG_ALIGN_DOWN(size);//use align_remain temporary to save aligned size.
if(align_remain > 0){//it may be 0 in this function.
result = ef_port_write(addr, buf, align_remain);
}
align_remain = size - 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);
}
return result;
}
static EfErrCode create_env_blob(sector_meta_data_t sector, const char *key, const void *value, size_t len)
{
EfErrCode result = EF_NO_ERR;
struct env_hdr_data env_hdr;
bool is_full = false;
uint32_t env_addr = sector->empty_env;
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;
}
memset(&env_hdr, 0xFF, sizeof(struct env_hdr_data));
env_hdr.magic = ENV_MAGIC_WORD;
env_hdr.name_len = strlen(key);
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) {
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) {
size_t align_remain;
/* update the sector status */
if (result == EF_NO_ERR) {
result = update_sec_status(sector, env_hdr.len, &is_full);
}
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--) {
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--) {
env_hdr.crc32 = ef_calc_crc32(env_hdr.crc32, &ff, 1);
}
/* write ENV header data */
result = write_env_hdr(env_addr, &env_hdr);
}
/* write key name */
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) {
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));
}
update_env_cache(key, env_hdr.name_len, env_addr);
#endif /* EF_ENV_USING_CACHE */
}
/* write value */
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);
}
/* change the ENV status to ENV_WRITE */
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) {
EF_DEBUG("Trigger a GC check after created ENV.\n");
gc_request = true;
}
} else {
result = EF_ENV_FULL;
}
return result;
}
/**
* Delete an ENV.
*
* @param key ENV name
*
* @return result
*/
EfErrCode ef_del_env(const char *key)
{
EfErrCode result = EF_NO_ERR;
if (!init_ok) {
EF_INFO("Error: ENV isn't initialize OK.\n");
return EF_ENV_INIT_FAILED;
}
/* lock the ENV cache */
ef_port_env_lock();
result = del_env(key, NULL, true);
/* unlock the ENV cache */
ef_port_env_unlock();
return result;
}
/**
* The same to ef_del_env on this mode
* It's compatibility with older versions (less then V4.0).
*
* @note this function is DEPRECATED
*
* @param key ENV name
*
* @return result
*/
EfErrCode ef_del_and_save_env(const char *key)
{
return ef_del_env(key);
}
static EfErrCode set_env(const char *key, const void *value_buf, size_t buf_len)
{
EfErrCode result = EF_NO_ERR;
static struct env_node_obj env;
static struct sector_meta_data sector;
bool env_is_found = false;
if (value_buf == NULL) {
result = del_env(key, NULL, true);
} else {
/* make sure the flash has enough space */
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) {
result = del_env(key, &env, false);
}
/* create the new ENV */
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) {
result = del_env(key, &env, true);
}
/* process the GC after set ENV */
if (gc_request) {
gc_collect();
}
}
return result;
}
/**
* Set a blob ENV. If it value is NULL, delete it.
* If not find it in flash, then create it.
*
* @param key ENV name
* @param value ENV value
* @param len ENV value length
*
* @return result
*/
EfErrCode ef_set_env_blob(const char *key, const void *value_buf, size_t buf_len)
{
EfErrCode result = EF_NO_ERR;
if (!init_ok) {
EF_INFO("ENV isn't initialize OK.\n");
return EF_ENV_INIT_FAILED;
}
/* lock the ENV cache */
ef_port_env_lock();
result = set_env(key, value_buf, buf_len);
/* unlock the ENV cache */
ef_port_env_unlock();
return result;
}
/**
* Set a string ENV. If it value is NULL, delete it.
* If not find it in flash, then create it.
*
* @param key ENV name
* @param value ENV value
*
* @return result
*/
EfErrCode ef_set_env(const char *key, const char *value)
{
return ef_set_env_blob(key, value, strlen(value));
}
/**
* The same to ef_set_env on this mode.
* It's compatibility with older versions (less then V4.0).
*
* @note this function is DEPRECATED
*
* @param key ENV name
* @param value ENV value
*
* @return result
*/
EfErrCode ef_set_and_save_env(const char *key, const char *value)
{
return ef_set_env_blob(key, value, strlen(value));
}
/**
* Save ENV to flash.
*
* @note this function is DEPRECATED
*/
EfErrCode ef_save_env(void)
{
/* do nothing not cur mode */
return EF_NO_ERR;
}
/**
* ENV set default.
*
* @return result
*/
EfErrCode ef_env_set_default(void)
{
EfErrCode result = EF_NO_ERR;
uint32_t addr, i, value_len;
struct sector_meta_data sector;
EF_ASSERT(default_env_set);
EF_ASSERT(default_env_set_size);
/* 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) {
result = format_sector(addr, SECTOR_NOT_COMBINED);
if (result != EF_NO_ERR) {
goto __exit;
}
}
/* create default ENV */
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) {
value_len = strlen(default_env_set[i].value);
} 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) {
goto __exit;
}
}
__exit:
/* unlock the ENV cache */
ef_port_env_unlock();
return result;
}
static bool print_env_cb(env_node_obj_t env, void *arg1, void *arg2)
{
bool value_is_str = true, print_value = false;
size_t *using_size = arg1;
if (env->crc_is_ok) {
/* calculate the total using flash size */
*using_size += env->len;
/* check ENV */
if (env->status == ENV_WRITE) {
ef_print("%.*s=", env->name_len, env->name);
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) {
size = sizeof(buf);
} else {
size = env->value_len - len;
}
ef_port_read(env->addr.value + len, (uint32_t *) buf, EF_WG_ALIGN(size));
if (print_value) {
ef_print("%.*s", size, buf);
} else if (!ef_is_str(buf, size)) {
value_is_str = false;
break;
}
}
} else {
value_is_str = false;
}
if (value_is_str && !print_value) {
print_value = true;
goto __reload;
} else if (!value_is_str) {
ef_print("blob @0x%08X %dbytes", env->addr.value, env->value_len);
}
ef_print("\n");
}
}
return false;
}
/**
* Print ENV.
*/
void ef_print_env(void)
{
struct env_node_obj env;
size_t using_size = 0;
if (!init_ok) {
EF_INFO("ENV isn't initialize OK.\n");
return;
}
/* lock the ENV cache */
ef_port_env_lock();
env_iterator(&env, &using_size, NULL, print_env_cb);
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);
/* unlock the ENV cache */
ef_port_env_unlock();
}
#ifdef EF_ENV_AUTO_UPDATE
/*
* Auto update ENV to latest default when current EF_ENV_VER_NUM is changed.
*/
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) {
/* check version number */
if (saved_ver_num != setting_ver_num) {
struct env_node_obj 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++) {
/* add a new ENV when it's not found */
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) {
value_len = strlen(default_env_set[i].value);
} 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 {
/* version number not changed now return */
return;
}
}
set_env(VER_NUM_ENV_NAME, &setting_ver_num, sizeof(size_t));
}
#endif /* EF_ENV_AUTO_UPDATE */
static bool check_sec_hdr_cb(sector_meta_data_t sector, void *arg1, void *arg2)
{
if (!sector->check_ok) {
size_t *failed_count = arg1;
EF_INFO("Warning: Sector header check failed. Format this sector (0x%08x).\n", sector->addr);
(*failed_count) ++;
format_sector(sector->addr, SECTOR_NOT_COMBINED);
}
return false;
}
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) {
/* make sure the GC request flag to true */
gc_request = true;
/* resume the GC operate */
gc_collect();
}
return false;
}
static bool check_and_recovery_env_cb(env_node_obj_t env, void *arg1, void *arg2)
{
/* recovery the prepare deleted ENV */
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) {
EF_DEBUG("Recovery the ENV successful.\n");
} 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) {
uint8_t status_table[ENV_STATUS_TABLE_SIZE];
/* the ENV has not write finish, change the status to error */
//TODO �����쳣������״̬װ��ͼ
write_status(env->addr.start, status_table, ENV_STATUS_NUM, ENV_ERR_HDR);
return true;
}
return false;
}
/**
* Check and load the flash ENV meta data.
*
* @return result
*/
EfErrCode ef_load_env(void)
{
EfErrCode result = EF_NO_ERR;
struct env_node_obj env;
struct sector_meta_data sector;
size_t check_failed_count = 0;
in_recovery_check = true;
/* 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) {
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 */
sector_iterator(§or, SECTOR_STORE_UNUSED, NULL, NULL, check_and_recovery_gc_cb, false);
__retry:
/* check all ENV for recovery */
env_iterator(&env, NULL, NULL, check_and_recovery_env_cb);
if (gc_request) {
gc_collect();
goto __retry;
}
in_recovery_check = false;
/* unlock the ENV cache */
ef_port_env_unlock();
return result;
}
/**
* Flash ENV initialize.
*
* @param default_env default ENV set for user
* @param default_env_size default ENV set size
*
* @return result
*/
EfErrCode ef_env_init(ef_env const *default_env, size_t default_env_size) {
EfErrCode result = EF_NO_ERR;
#ifdef EF_ENV_USING_CACHE
size_t i;
#endif
EF_ASSERT(default_env);
EF_ASSERT(ENV_AREA_SIZE);
/* must be aligned with erase_min_size */
EF_ASSERT(ENV_AREA_SIZE % EF_ERASE_MIN_SIZE == 0);
/* sector number must be greater than or equal to 2 */
EF_ASSERT(SECTOR_NUM >= 2);
/* must be aligned with write granularity */
EF_ASSERT((EF_STR_ENV_VALUE_MAX_SIZE * 8) % EF_WRITE_GRAN == 0);
if (init_ok) {
return EF_NO_ERR;
}
#ifdef EF_ENV_USING_CACHE
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++) {
env_cache_table[i].addr = FAILED_ADDR;
}
#endif /* EF_ENV_USING_CACHE */
env_start_addr = EF_START_ADDR;
default_env_set = default_env;
default_env_set_size = default_env_size;
EF_DEBUG("ENV start address is 0x%08X, size is %d bytes.\n", EF_START_ADDR, ENV_AREA_SIZE);
result = ef_load_env();
#ifdef EF_ENV_AUTO_UPDATE
if (result == EF_NO_ERR) {
env_auto_update();
}
#endif
if (result == EF_NO_ERR) {
init_ok = true;
}
return result;
}
#endif /* defined(EF_USING_ENV) && !defined(EF_ENV_USING_LEGACY_MODE) */