|
|
|
@ -39,6 +39,11 @@
|
|
|
|
#error "the write gran can be only setting as 1, 8, 32 and 64"
|
|
|
|
#error "the write gran can be only setting as 1, 8, 32 and 64"
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* the ENV max name length must less then it */
|
|
|
|
|
|
|
|
#ifndef EF_ENV_NAME_MAX
|
|
|
|
|
|
|
|
#define EF_ENV_NAME_MAX 32
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* magic word(`E`, `F`, `4`, `0`) */
|
|
|
|
/* magic word(`E`, `F`, `4`, `0`) */
|
|
|
|
#define SECTOR_MAGIC_WORD 0x30344645
|
|
|
|
#define SECTOR_MAGIC_WORD 0x30344645
|
|
|
|
/* magic word(`K`, `V`, `4`, `0`) */
|
|
|
|
/* magic word(`K`, `V`, `4`, `0`) */
|
|
|
|
@ -149,6 +154,17 @@ enum sector_dirty_status {
|
|
|
|
};
|
|
|
|
};
|
|
|
|
typedef enum sector_dirty_status sector_dirty_status_t;
|
|
|
|
typedef enum sector_dirty_status sector_dirty_status_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
enum env_status {
|
|
|
|
|
|
|
|
ENV_UNUSED,
|
|
|
|
|
|
|
|
ENV_PRE_WRITE,
|
|
|
|
|
|
|
|
ENV_WRITE,
|
|
|
|
|
|
|
|
ENV_PRE_DELETE,
|
|
|
|
|
|
|
|
ENV_DELETED,
|
|
|
|
|
|
|
|
ENV_ERR_HDR,
|
|
|
|
|
|
|
|
ENV_STATUS_NUM,
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef enum env_status env_status_t;
|
|
|
|
|
|
|
|
|
|
|
|
struct sector_hdr_data {
|
|
|
|
struct sector_hdr_data {
|
|
|
|
struct {
|
|
|
|
struct {
|
|
|
|
uint8_t store[STORE_STATUS_TABLE_SIZE]; /**< sector store status @see sector_store_status_t */
|
|
|
|
uint8_t store[STORE_STATUS_TABLE_SIZE]; /**< sector store status @see sector_store_status_t */
|
|
|
|
@ -184,6 +200,21 @@ struct env_hdr_data {
|
|
|
|
};
|
|
|
|
};
|
|
|
|
typedef struct env_hdr_data *env_hdr_data_t;
|
|
|
|
typedef struct env_hdr_data *env_hdr_data_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 */
|
|
|
|
|
|
|
|
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 value_len; /**< value length */
|
|
|
|
|
|
|
|
char name[EF_ENV_NAME_MAX]; /**< name */
|
|
|
|
|
|
|
|
struct {
|
|
|
|
|
|
|
|
uint32_t start; /**< ENV node start address */
|
|
|
|
|
|
|
|
uint32_t value; /**< value start address */
|
|
|
|
|
|
|
|
} addr;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct env_meta_data *env_meta_data_t;
|
|
|
|
|
|
|
|
|
|
|
|
struct env_cache_node {
|
|
|
|
struct env_cache_node {
|
|
|
|
uint16_t name_crc; /**< ENV name's CRC32 low 16bit value */
|
|
|
|
uint16_t name_crc; /**< ENV name's CRC32 low 16bit value */
|
|
|
|
uint16_t active; /**< ENV node access active degree */
|
|
|
|
uint16_t active; /**< ENV node access active degree */
|
|
|
|
@ -424,17 +455,12 @@ static bool get_env_from_cache(const char *name, size_t name_len, uint32_t *addr
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
static uint32_t continue_ff_addr(uint32_t start, uint32_t end)
|
|
|
|
static uint32_t continue_ff_addr(uint32_t start, uint32_t end)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
uint8_t buf[EF_READ_BUF_SIZE], last_data = 0x00;
|
|
|
|
uint8_t buf[32], last_data = 0x00;
|
|
|
|
size_t i, addr = start, read_size;
|
|
|
|
size_t i, addr = start;
|
|
|
|
|
|
|
|
|
|
|
|
for (; start < end; start += sizeof(buf)) {
|
|
|
|
for (; start < end; start += sizeof(buf)) {
|
|
|
|
if (start + sizeof(buf) < end) {
|
|
|
|
ef_port_read(start, (uint32_t *) buf, sizeof(buf));
|
|
|
|
read_size = sizeof(buf);
|
|
|
|
for (i = 0; i < sizeof(buf) && start + i < end; i++) {
|
|
|
|
} 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) {
|
|
|
|
if (last_data != 0xFF && buf[i] == 0xFF) {
|
|
|
|
addr = start + i;
|
|
|
|
addr = start + i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -469,11 +495,7 @@ static uint32_t find_next_env_addr(uint32_t start, uint32_t end)
|
|
|
|
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));
|
|
|
|
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);
|
|
|
|
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;
|
|
|
|
return start + i - ENV_MAGIC_OFFSET;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -483,7 +505,7 @@ static uint32_t find_next_env_addr(uint32_t start, uint32_t end)
|
|
|
|
return FAILED_ADDR;
|
|
|
|
return FAILED_ADDR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static uint32_t get_next_env_addr(sector_meta_data_t sector, env_node_obj_t pre_env)
|
|
|
|
static uint32_t get_next_env_addr(sector_meta_data_t sector, env_meta_data_t pre_env)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
uint32_t addr = FAILED_ADDR;
|
|
|
|
uint32_t addr = FAILED_ADDR;
|
|
|
|
|
|
|
|
|
|
|
|
@ -507,7 +529,7 @@ static uint32_t get_next_env_addr(sector_meta_data_t sector, env_node_obj_t pre_
|
|
|
|
addr = find_next_env_addr(addr, sector->addr + SECTOR_SIZE - SECTOR_HDR_DATA_SIZE);
|
|
|
|
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 扇区连续模式
|
|
|
|
//TODO 扇区连续模式
|
|
|
|
return FAILED_ADDR;
|
|
|
|
return FAILED_ADDR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
@ -519,10 +541,10 @@ static uint32_t get_next_env_addr(sector_meta_data_t sector, env_node_obj_t pre_
|
|
|
|
return addr;
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static EfErrCode read_env(env_node_obj_t env)
|
|
|
|
static EfErrCode read_env(env_meta_data_t env)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
struct env_hdr_data env_hdr;
|
|
|
|
struct env_hdr_data env_hdr;
|
|
|
|
uint8_t buf[EF_READ_BUF_SIZE];
|
|
|
|
uint8_t buf[32];
|
|
|
|
uint32_t calc_crc32 = 0, crc_data_len, env_name_addr;
|
|
|
|
uint32_t calc_crc32 = 0, crc_data_len, env_name_addr;
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
size_t len, size;
|
|
|
|
size_t len, size;
|
|
|
|
@ -542,7 +564,7 @@ static EfErrCode read_env(env_node_obj_t env)
|
|
|
|
env->crc_is_ok = false;
|
|
|
|
env->crc_is_ok = false;
|
|
|
|
return EF_READ_ERR;
|
|
|
|
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 扇区连续模式，或者写入长度没有写入完整
|
|
|
|
//TODO 扇区连续模式，或者写入长度没有写入完整
|
|
|
|
EF_ASSERT(0);
|
|
|
|
EF_ASSERT(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -593,7 +615,6 @@ static EfErrCode read_sector_meta_data(uint32_t addr, sector_meta_data_t sector,
|
|
|
|
/* check magic word */
|
|
|
|
/* check magic word */
|
|
|
|
if (sector->magic != SECTOR_MAGIC_WORD) {
|
|
|
|
if (sector->magic != SECTOR_MAGIC_WORD) {
|
|
|
|
sector->check_ok = false;
|
|
|
|
sector->check_ok = false;
|
|
|
|
sector->combined = SECTOR_NOT_COMBINED;
|
|
|
|
|
|
|
|
return EF_ENV_INIT_FAILED;
|
|
|
|
return EF_ENV_INIT_FAILED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sector->check_ok = true;
|
|
|
|
sector->check_ok = true;
|
|
|
|
@ -608,7 +629,7 @@ static EfErrCode read_sector_meta_data(uint32_t addr, sector_meta_data_t sector,
|
|
|
|
if (sector->status.store == SECTOR_STORE_EMPTY) {
|
|
|
|
if (sector->status.store == SECTOR_STORE_EMPTY) {
|
|
|
|
sector->remain = SECTOR_SIZE - SECTOR_HDR_DATA_SIZE;
|
|
|
|
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_node_obj env_meta;
|
|
|
|
struct env_meta_data env_meta;
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef EF_ENV_USING_CACHE
|
|
|
|
#ifdef EF_ENV_USING_CACHE
|
|
|
|
if (get_sector_from_cache(addr, §or->empty_env)) {
|
|
|
|
if (get_sector_from_cache(addr, §or->empty_env)) {
|
|
|
|
@ -677,8 +698,8 @@ static uint32_t get_next_sector_addr(sector_meta_data_t pre_sec)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void env_iterator(env_node_obj_t env, void *arg1, void *arg2,
|
|
|
|
static void env_iterator(env_meta_data_t env, void *arg1, void *arg2,
|
|
|
|
bool (*callback)(env_node_obj_t env, void *arg1, void *arg2))
|
|
|
|
bool (*callback)(env_meta_data_t env, void *arg1, void *arg2))
|
|
|
|
{
|
|
|
|
{
|
|
|
|
struct sector_meta_data sector;
|
|
|
|
struct sector_meta_data sector;
|
|
|
|
uint32_t sec_addr;
|
|
|
|
uint32_t sec_addr;
|
|
|
|
@ -707,24 +728,24 @@ static void env_iterator(env_node_obj_t env, void *arg1, void *arg2,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool find_env_cb(env_node_obj_t env, void *arg1, void *arg2)
|
|
|
|
static bool find_env_cb(env_meta_data_t env, void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
const char *key = arg1;
|
|
|
|
const char *key = arg1;
|
|
|
|
bool *find_ok = arg2;
|
|
|
|
bool *find_ok = arg2;
|
|
|
|
size_t key_len = strlen(key);
|
|
|
|
uint8_t max_len = strlen(key);
|
|
|
|
|
|
|
|
|
|
|
|
if (key_len != env->name_len) {
|
|
|
|
if (max_len < env->name_len) {
|
|
|
|
return false;
|
|
|
|
max_len = env->name_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* check ENV */
|
|
|
|
/* check ENV */
|
|
|
|
if (env->crc_is_ok && env->status == ENV_WRITE && !strncmp(env->name, key, key_len)) {
|
|
|
|
if (env->crc_is_ok && env->status == ENV_WRITE && !strncmp(env->name, key, max_len)) {
|
|
|
|
*find_ok = true;
|
|
|
|
*find_ok = true;
|
|
|
|
return true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool find_env_no_cache(const char *key, env_node_obj_t env)
|
|
|
|
static bool find_env_no_cache(const char *key, env_meta_data_t env)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
bool find_ok = false;
|
|
|
|
bool find_ok = false;
|
|
|
|
|
|
|
|
|
|
|
|
@ -733,7 +754,7 @@ static bool find_env_no_cache(const char *key, env_node_obj_t env)
|
|
|
|
return find_ok;
|
|
|
|
return find_ok;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool find_env(const char *key, env_node_obj_t env)
|
|
|
|
static bool find_env(const char *key, env_meta_data_t env)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
bool find_ok = false;
|
|
|
|
bool find_ok = false;
|
|
|
|
|
|
|
|
|
|
|
|
@ -772,7 +793,7 @@ static bool ef_is_str(uint8_t *value, size_t len)
|
|
|
|
|
|
|
|
|
|
|
|
static size_t get_env(const char *key, void *value_buf, size_t buf_len, size_t *value_len)
|
|
|
|
static size_t get_env(const char *key, void *value_buf, size_t buf_len, size_t *value_len)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
struct env_node_obj env;
|
|
|
|
struct env_meta_data env;
|
|
|
|
size_t read_len = 0;
|
|
|
|
size_t read_len = 0;
|
|
|
|
|
|
|
|
|
|
|
|
if (find_env(key, &env)) {
|
|
|
|
if (find_env(key, &env)) {
|
|
|
|
@ -784,44 +805,12 @@ static size_t get_env(const char *key, void *value_buf, size_t buf_len, size_t *
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
read_len = buf_len;
|
|
|
|
read_len = buf_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (value_buf){
|
|
|
|
ef_port_read(env.addr.value, (uint32_t *) value_buf, read_len);
|
|
|
|
ef_port_read(env.addr.value, (uint32_t *) value_buf, read_len);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (value_len) {
|
|
|
|
|
|
|
|
*value_len = 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return read_len;
|
|
|
|
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.
|
|
|
|
* Get a blob ENV value by key name.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
@ -881,45 +870,6 @@ char *ef_get_env(const char *key)
|
|
|
|
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) {
|
|
|
|
static EfErrCode write_env_hdr(uint32_t addr, env_hdr_data_t env_hdr) {
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
/* write the status will by write granularity */
|
|
|
|
/* write the status will by write granularity */
|
|
|
|
@ -1066,7 +1016,7 @@ static uint32_t alloc_env(sector_meta_data_t sector, size_t env_size)
|
|
|
|
return empty_env;
|
|
|
|
return empty_env;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static EfErrCode del_env(const char *key, env_node_obj_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;
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
uint32_t dirty_status_addr;
|
|
|
|
uint32_t dirty_status_addr;
|
|
|
|
static bool last_is_complete_del = false;
|
|
|
|
static bool last_is_complete_del = false;
|
|
|
|
@ -1079,7 +1029,7 @@ static EfErrCode del_env(const char *key, env_node_obj_t old_env, bool complete_
|
|
|
|
|
|
|
|
|
|
|
|
/* need find ENV */
|
|
|
|
/* need find ENV */
|
|
|
|
if (!old_env) {
|
|
|
|
if (!old_env) {
|
|
|
|
struct env_node_obj env;
|
|
|
|
struct env_meta_data env;
|
|
|
|
/* find ENV */
|
|
|
|
/* find ENV */
|
|
|
|
if (find_env(key, &env)) {
|
|
|
|
if (find_env(key, &env)) {
|
|
|
|
old_env = &env;
|
|
|
|
old_env = &env;
|
|
|
|
@ -1097,14 +1047,8 @@ static EfErrCode del_env(const char *key, env_node_obj_t old_env, bool complete_
|
|
|
|
|
|
|
|
|
|
|
|
if (!last_is_complete_del && result == EF_NO_ERR) {
|
|
|
|
if (!last_is_complete_del && result == EF_NO_ERR) {
|
|
|
|
#ifdef EF_ENV_USING_CACHE
|
|
|
|
#ifdef EF_ENV_USING_CACHE
|
|
|
|
/* delete the ENV in flash and cache */
|
|
|
|
/* only delete the ENV in flash and cache when only using del_env(key, env, true) in ef_del_env() */
|
|
|
|
if (key != NULL) {
|
|
|
|
update_env_cache(key, strlen(key), FAILED_ADDR);
|
|
|
|
/* 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 */
|
|
|
|
#endif /* EF_ENV_USING_CACHE */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -1124,7 +1068,7 @@ static EfErrCode del_env(const char *key, env_node_obj_t old_env, bool complete_
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* move the ENV to new space
|
|
|
|
* move the ENV to new space
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
static EfErrCode move_env(env_node_obj_t env)
|
|
|
|
static EfErrCode move_env(env_meta_data_t env)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
uint8_t status_table[ENV_STATUS_TABLE_SIZE];
|
|
|
|
uint8_t status_table[ENV_STATUS_TABLE_SIZE];
|
|
|
|
@ -1138,7 +1082,7 @@ static EfErrCode move_env(env_node_obj_t env)
|
|
|
|
|
|
|
|
|
|
|
|
if ((env_addr = alloc_env(§or, env->len)) != FAILED_ADDR) {
|
|
|
|
if ((env_addr = alloc_env(§or, env->len)) != FAILED_ADDR) {
|
|
|
|
if (in_recovery_check) {
|
|
|
|
if (in_recovery_check) {
|
|
|
|
struct env_node_obj env_bak;
|
|
|
|
struct env_meta_data env_bak;
|
|
|
|
char name[EF_ENV_NAME_MAX + 1] = { 0 };
|
|
|
|
char name[EF_ENV_NAME_MAX + 1] = { 0 };
|
|
|
|
strncpy(name, env->name, env->name_len);
|
|
|
|
strncpy(name, env->name, env->name_len);
|
|
|
|
/* check the ENV in flash is already create success */
|
|
|
|
/* check the ENV in flash is already create success */
|
|
|
|
@ -1225,7 +1169,7 @@ static bool gc_check_cb(sector_meta_data_t sector, void *arg1, void *arg2)
|
|
|
|
|
|
|
|
|
|
|
|
static bool do_gc(sector_meta_data_t sector, void *arg1, void *arg2)
|
|
|
|
static bool do_gc(sector_meta_data_t sector, void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
struct env_node_obj env;
|
|
|
|
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];
|
|
|
|
uint8_t status_table[DIRTY_STATUS_TABLE_SIZE];
|
|
|
|
@ -1286,13 +1230,9 @@ static EfErrCode align_write(uint32_t addr, const uint32_t *buf, size_t size)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
memset(align_data, 0xFF, align_data_size);
|
|
|
|
memset(align_data, 0xFF, align_data_size);
|
|
|
|
align_remain = EF_WG_ALIGN_DOWN(size);//use align_remain temporary to save aligned size.
|
|
|
|
result = ef_port_write(addr, buf, EF_WG_ALIGN_DOWN(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;
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
result = ef_port_write(addr + EF_WG_ALIGN_DOWN(size), (uint32_t *) align_data, align_data_size);
|
|
|
|
@ -1426,7 +1366,7 @@ EfErrCode ef_del_and_save_env(const char *key)
|
|
|
|
static EfErrCode set_env(const char *key, const void *value_buf, size_t buf_len)
|
|
|
|
static EfErrCode set_env(const char *key, const void *value_buf, size_t buf_len)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
static struct env_node_obj env;
|
|
|
|
static struct env_meta_data env;
|
|
|
|
static struct sector_meta_data sector;
|
|
|
|
static struct sector_meta_data sector;
|
|
|
|
bool env_is_found = false;
|
|
|
|
bool env_is_found = false;
|
|
|
|
|
|
|
|
|
|
|
|
@ -1577,7 +1517,7 @@ __exit:
|
|
|
|
return result;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool print_env_cb(env_node_obj_t env, void *arg1, void *arg2)
|
|
|
|
static bool print_env_cb(env_meta_data_t env, void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
bool value_is_str = true, print_value = false;
|
|
|
|
bool value_is_str = true, print_value = false;
|
|
|
|
size_t *using_size = arg1;
|
|
|
|
size_t *using_size = arg1;
|
|
|
|
@ -1630,7 +1570,7 @@ __reload:
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
void ef_print_env(void)
|
|
|
|
void ef_print_env(void)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
struct env_node_obj env;
|
|
|
|
struct env_meta_data env;
|
|
|
|
size_t using_size = 0;
|
|
|
|
size_t using_size = 0;
|
|
|
|
|
|
|
|
|
|
|
|
if (!init_ok) {
|
|
|
|
if (!init_ok) {
|
|
|
|
@ -1662,7 +1602,7 @@ static void env_auto_update(void)
|
|
|
|
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 */
|
|
|
|
/* check version number */
|
|
|
|
if (saved_ver_num != setting_ver_num) {
|
|
|
|
if (saved_ver_num != setting_ver_num) {
|
|
|
|
struct env_node_obj env;
|
|
|
|
struct env_meta_data env;
|
|
|
|
size_t i, value_len;
|
|
|
|
size_t i, value_len;
|
|
|
|
struct sector_meta_data sector;
|
|
|
|
struct sector_meta_data sector;
|
|
|
|
EF_DEBUG("Update the ENV from version %d to %d.\n", saved_ver_num, setting_ver_num);
|
|
|
|
EF_DEBUG("Update the ENV from version %d to %d.\n", saved_ver_num, setting_ver_num);
|
|
|
|
@ -1715,7 +1655,7 @@ static bool check_and_recovery_gc_cb(sector_meta_data_t sector, void *arg1, void
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool check_and_recovery_env_cb(env_node_obj_t env, void *arg1, void *arg2)
|
|
|
|
static bool check_and_recovery_env_cb(env_meta_data_t env, void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
/* recovery the prepare deleted ENV */
|
|
|
|
/* 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) {
|
|
|
|
@ -1730,7 +1670,7 @@ static bool check_and_recovery_env_cb(env_node_obj_t env, void *arg1, void *arg2
|
|
|
|
} else if (env->status == ENV_PRE_WRITE) {
|
|
|
|
} else if (env->status == ENV_PRE_WRITE) {
|
|
|
|
uint8_t status_table[ENV_STATUS_TABLE_SIZE];
|
|
|
|
uint8_t status_table[ENV_STATUS_TABLE_SIZE];
|
|
|
|
/* the ENV has not write finish, change the status to error */
|
|
|
|
/* the ENV has not write finish, change the status to error */
|
|
|
|
//TODO 绘制异常处理的状态装换图
|
|
|
|
//TODO 绘制异常处理的状态装换图
|
|
|
|
write_status(env->addr.start, status_table, ENV_STATUS_NUM, ENV_ERR_HDR);
|
|
|
|
write_status(env->addr.start, status_table, ENV_STATUS_NUM, ENV_ERR_HDR);
|
|
|
|
return true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1746,10 +1686,13 @@ static bool check_and_recovery_env_cb(env_node_obj_t env, void *arg1, void *arg2
|
|
|
|
EfErrCode ef_load_env(void)
|
|
|
|
EfErrCode ef_load_env(void)
|
|
|
|
{
|
|
|
|
{
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
EfErrCode result = EF_NO_ERR;
|
|
|
|
struct env_node_obj env;
|
|
|
|
struct env_meta_data env;
|
|
|
|
struct sector_meta_data sector;
|
|
|
|
struct sector_meta_data sector;
|
|
|
|
size_t check_failed_count = 0;
|
|
|
|
size_t check_failed_count = 0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* lock the ENV cache */
|
|
|
|
|
|
|
|
ef_port_env_lock();
|
|
|
|
|
|
|
|
|
|
|
|
in_recovery_check = true;
|
|
|
|
in_recovery_check = true;
|
|
|
|
/* check all sector header */
|
|
|
|
/* check all sector header */
|
|
|
|
sector_iterator(§or, SECTOR_STORE_UNUSED, &check_failed_count, NULL, check_sec_hdr_cb, false);
|
|
|
|
sector_iterator(§or, SECTOR_STORE_UNUSED, &check_failed_count, NULL, check_sec_hdr_cb, false);
|
|
|
|
@ -1758,9 +1701,6 @@ EfErrCode ef_load_env(void)
|
|
|
|
EF_INFO("Warning: All sector header check failed. Set it to default.\n");
|
|
|
|
EF_INFO("Warning: All sector header check failed. Set it to default.\n");
|
|
|
|
ef_env_set_default();
|
|
|
|
ef_env_set_default();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* lock the ENV cache */
|
|
|
|
|
|
|
|
ef_port_env_lock();
|
|
|
|
|
|
|
|
/* check all sector header for recovery GC */
|
|
|
|
/* check all sector header for recovery GC */
|
|
|
|
sector_iterator(§or, SECTOR_STORE_UNUSED, NULL, NULL, check_and_recovery_gc_cb, false);
|
|
|
|
sector_iterator(§or, SECTOR_STORE_UNUSED, NULL, NULL, check_and_recovery_gc_cb, false);
|
|
|
|
|
|
|
|
|
|
|
|
|
