/*!
@brief fta_initialize
FTA initialize function
@param none
@retval none
*/
void fta_initialize(void)
{
boolean dofirst = (fta_manager == NULL ? TRUE : FALSE);
if(!dofirst) {
memset(&fta_lock_keeper, 0, sizeof(fta_lock_keeper));
memset(&fta_reference, 0, sizeof(fta_reference));
}
memset(fta_log_area,0,FTA_CONFIG_STORE_MEMORY_SIZE);
fta_manager = (fta_manager_store_header *)fta_log_area;
fta_manager_initializer.fta_manager = fta_manager;
fta_manager_initializer.memory_addr = FTA_LIB_OFFSET_ADDR(((uint8 *)fta_manager), FTA_CALC_MANAGER_SIZE(FTA_CONFIG_STORE_INITIAL_COUNT));
if(_fta_manage_initialize(&fta_manager_initializer)) {
_fta_manage_initialize_store_items(fta_manager);
fta_manager->cmn.enabled = FTA_STORE_ENABLED_TRUE;
FTA_LIB_CHANGEBIT_SET(fta_manager->cmn.statbit, FTA_STORE_STATBIT_RECORDING);
fta_manager->parity = fta_lib_check_parity16((uint16 *)fta_manager, fta_manager->cmn.size / 2, fta_manager->parity);
FTA_MEMORY_FLUSH();
fta_lock_keeper.manager_status = FTA_MANAGER_STATUS_ENABLED;
/* start logging */
FTA_LOG_MESSAGE(FTA_ADMIN, FTA_LOG_LEVEL_NOTICE, "*** FTA INITIALIZED %x %x", fta_log_area, virt_to_phys(fta_log_area),0);
}
return;
}
/*!
@brief _fta_lisext_hash_record
operate the list hash record
@param [in] p_store_item item for manage
@param [in] access_info access information
@param [in] key_info key
@param [in] access_type FTA_LISTEX_HASH_ACCESS_GET: get record
FTA_LISTEX_HASH_ACCESS_ADD: add record
FTA_LISTEX_HASH_ACCESS_DEL: del record
@retval NULL: not found / over the max record
@retval others: pointer of record
*/
void *_fta_listex_hash_record(const fta_manager_store_item * const *p_store_item,
const fta_listex_hash_access_info *access_info,
const void *key_info, uint32 access_type)
{
fta_list_store_header *list_header;
void *list_record = NULL;
/* parameter check */
if(p_store_item == NULL || access_info == NULL || key_info == NULL ||
access_type >= FTA_LISTEX_HASH_ACCESS_MAX) {
FTA_LOG_MESSAGE(FTA_LIST, FTA_LOG_LEVEL_CRITICAL, "*** FTA LIST INTERNAL ERROR", 0, 0, 0);
return NULL;
}
if(access_info->work_buffer == NULL) {
FTA_LOG_MESSAGE(FTA_LIST, FTA_LOG_LEVEL_CRITICAL, "*** FTA LIST CONFIG ERROR", 0, 0, 0);
return NULL;
}
if(access_info->lock_access) {
FTA_ENTER_LOCK();
/* - - - - - - - - */
do {
if(*p_store_item == NULL) {
break;
}
if((*p_store_item)->lock_keeper->manager_status != FTA_MANAGER_STATUS_ENABLED) {
break;
}
list_header = (fta_list_store_header *)((*p_store_item)->addr);
list_record = _fta_listex_hash_record_i(list_header, access_info, key_info, access_type);
} while(FALSE);
/* - - - - - - - - */
FTA_LEAVE_LOCK();
} else {
list_header = (fta_list_store_header *)((*p_store_item)->addr);
list_record = _fta_listex_hash_record_i(list_header, access_info, key_info, access_type);
}
return list_record;
}
/*!
@brief _fta_listex_hash_init_common
initialize for list hash area
@param [in] store_item item for manage
@retval none
@note it is necessary to use initialize macro FTA_CONFIG_STORE_ITEM_DEF2
@note instead of FTA_CONFIG_STORE_ITEN_DEF in configuration.
*/
void _fta_listex_hash_init_common(fta_manager_store_item *store_item)
{
fta_list_store_header *list_header = (fta_list_store_header *)(store_item->addr);
const fta_listex_hash_access_info *access_info;
uint32 fixed_len;
/* initialize */
list_header->count = 0;
list_header->version = FTA_LIST_VERSION_HASH;
list_header->quota = FTA_LIST_QUOTA_DEFAULT;
list_header->bottom = 0;
/* set to record manager */
access_info = store_item->def->add_param;
if(access_info == NULL) {
goto _fta_listex_hash_init_common_exit;
}
/* check record manager */
fixed_len = FTA_LIB_ALIGN4_32(access_info->fixed_len);
if((fixed_len < access_info->key_size) ||
(fixed_len > list_header->cmn.size - list_header->cmn.offset) ||
(access_info->entry_max == 0) ||
(access_info->entry_max >= FTA_LISTEX_HASH_ID_EMPTY) ||
(access_info->entry_max * fixed_len >= list_header->cmn.size - list_header->cmn.offset) ||
(access_info->hash_size == 0) ||
(access_info->work_buffer == 0)) {
goto _fta_listex_hash_init_common_exit;
}
/* initialize wake area */
memset(access_info->work_buffer, FTA_LISTEX_HASH_ID_EMPTY_RESET,
FTA_LISTEX_HASH_WORK_MAX(access_info->entry_max, access_info->hash_size) *
sizeof(fta_listex_hash_id_type));
list_header->cmn.enabled = TRUE;
FTA_LIB_CHANGEBIT_SET(list_header->cmn.statbit, FTA_STORE_STATBIT_RECORDING);
return;
_fta_listex_hash_init_common_exit: ;
FTA_LOG_MESSAGE(FTA_LIST, FTA_LOG_LEVEL_CRITICAL, "*** FTA LIST CONFIG ERROR", 0, 0, 0);
return;
}
/*!
@brief _fta_var_alloc
allocate the list record
@param [in] p_store_item item for manage
@param [in] access_info access information
@param [in] key_info key
@param [in] alloc_len size of the record
@retval NULL: over the max record
@retval others: pointer of record
*/
void *_fta_var_alloc(const fta_manager_store_item * const *p_store_item,
const fta_var_record_access_info *access_info, const void *key_info, uint32 alloc_len)
{
fta_var_store_header *var_header;
void *var_record = NULL;
if(p_store_item == NULL || access_info == NULL || key_info == NULL) {
FTA_LOG_MESSAGE(FTA_VAR, FTA_LOG_LEVEL_CRITICAL, "*** FTA VAR INTERNAL ERROR", 0, 0, 0);
return NULL;
}
if(access_info->lock_access) {
FTA_ENTER_LOCK();
/* - - - - - - - - */
do {
if(*p_store_item == NULL) {
break;
}
if((*p_store_item)->lock_keeper->manager_status != FTA_MANAGER_STATUS_ENABLED) {
break;
}
var_header = (fta_var_store_header *)((*p_store_item)->addr);
var_record = _fta_var_alloc_i(var_header, access_info, key_info, alloc_len);
} while(FALSE);
/* - - - - - - - - */
FTA_LEAVE_LOCK();
} else {
var_header = (fta_var_store_header *)((*p_store_item)->addr);
var_record = _fta_var_alloc_i(var_header, access_info, key_info, alloc_len);
}
return var_record;
}
/*!
@brief _fta_lisext_hash_record?i
internal functionn of operating the list hash record
@param [in] p_store_item item for manage
@param [in] access_info access information
@param [in] key_info key
@param [in] access_type FTA_LISTEX_HASH_ACCESS_GET: get record
FTA_LISTEX_HASH_ACCESS_ADD: add record
FTA_LISTEX_HASH_ACCESS_DEL: del record
@retval NULL: not found / over the max record
@retval others: pointer of record
*/
static void *_fta_listex_hash_record_i(fta_list_store_header *list_header,
const fta_listex_hash_access_info *access_info,
const void *key_info, uint32 access_type)
{
uint8 *list_dataarea;
void *list_record = NULL;
uint32 fixed_len;
uint32 key_size;
uint32 record_par;
uint32 record_num;
fta_listex_hash_id_type *work_buffer;
boolean not_found;
/* check of a recordable state or an effective state */
if(access_type != FTA_LISTEX_HASH_ACCESS_GET) {
if(!FTA_LIB_CHECKBIT(list_header->cmn.statbit, FTA_STORE_STATBIT_RECORDING)) {
goto _fta_listex_hash_record_exit;
}
} else {
if(list_header->cmn.enabled != FTA_STORE_ENABLED_TRUE) {
goto _fta_listex_hash_record_exit;
}
}
fixed_len = FTA_LIB_ALIGN4_32(access_info->fixed_len);
key_size = access_info->key_size;
list_dataarea = FTA_LIB_OFFSET_ADDR(list_header, list_header->cmn.offset);
work_buffer = access_info->work_buffer;
/* registered check */
not_found = TRUE;
record_par = 0;
memcpy(&record_par, key_info, (key_size > sizeof(uint32) ? sizeof(uint32) : key_size));
record_par %= access_info->hash_size; /* only to 4 bytes of low rank */
record_par += FTA_LISTEX_HASH_BUF_HASHEDINDEX;
if(list_header->count > 0) {
/* search for the same item */
record_num = work_buffer[record_par];
while(record_num != FTA_LISTEX_HASH_ID_EMPTY) {
list_record = (void *)FTA_LIB_OFFSET_ADDR(list_dataarea, record_num * fixed_len);
if(memcmp(key_info, list_record, key_size) == 0) {
not_found = FALSE;
break;
}
record_par = record_num;
record_num = work_buffer[record_par];
}
}
if(not_found) {
/* add record */
if(access_type == FTA_LISTEX_HASH_ACCESS_ADD) {
if(list_header->count == 0) {
/* simple work area check only once after initialization */
if(work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] != FTA_LISTEX_HASH_ID_EMPTY ||
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] != FTA_LISTEX_HASH_ID_EMPTY ||
work_buffer[FTA_LISTEX_HASH_BUF_HASHEDINDEX] != FTA_LISTEX_HASH_ID_EMPTY ) {
FTA_LOG_MESSAGE(FTA_LIST, FTA_LOG_LEVEL_CRITICAL, "*** FTA LIST CONFIG ERROR", 0, 0, 0);
list_record = NULL;
goto _fta_listex_hash_record_exit;
}
}
/* a new record is added */
if((uint32)(list_header->count) >= access_info->entry_max) {
/* acquires from an empty list when the number of registration is a maximum */
record_num = work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN];
if(record_num == FTA_LISTEX_HASH_ID_EMPTY) {
list_record = NULL;
goto _fta_listex_hash_record_exit;
}
/* deletes from an empty list */
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] = work_buffer[record_num];
if(work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] == record_num) {
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] = FTA_LISTEX_HASH_ID_EMPTY;
}
} else {
/* adds a new record until the number of registration is a maximum*/
record_num = list_header->count;
list_header->count++;
list_header->bottom = list_header->count * fixed_len;
}
/* adds to hash table */
work_buffer[record_num] = work_buffer[record_par];
work_buffer[record_par] = (fta_listex_hash_id_type)record_num;
/* return the record position */
list_record = (void *)FTA_LIB_OFFSET_ADDR(list_dataarea, record_num * fixed_len);
memcpy(list_record, key_info, key_size);
} else {
/* do noting */
list_record = NULL;
}
} else {
/* delete record */
if(access_type == FTA_LISTEX_HASH_ACCESS_DEL) {
/* set the delete bit */
((uint8*)list_record)[key_size - 1] |= 0x80;
/* deletes from the list and adds to an empty entry */
work_buffer[record_par] = work_buffer[record_num];
work_buffer[record_num] = FTA_LISTEX_HASH_ID_EMPTY;
if(work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] == FTA_LISTEX_HASH_ID_EMPTY) {
/* with no empty entry */
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_BEGIN] = (fta_listex_hash_id_type)record_num;
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] = (fta_listex_hash_id_type)record_num;
} else {
/* add to a termination */
work_buffer[work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END]] = (fta_listex_hash_id_type)record_num;
work_buffer[FTA_LISTEX_HASH_BUF_EMPTY_END] = (fta_listex_hash_id_type)record_num;
}
}
}
_fta_listex_hash_record_exit: ;
return list_record;
}
/*!
@brief _fta_var_find
sarch for the record
@param [in] p_store_item item for manage
@param [in] key_info key
@param [in] alloc_len size of the record
@retval NULL: not found
@retval others: pointer of record
*/
void *_fta_var_find(const fta_manager_store_item * const *p_store_item,
const fta_var_record_access_info *access_info, const void *key_info)
{
fta_var_store_header *var_header;
void *var_record = NULL;
uint8 *var_dataarea = NULL;
uint32 dataarea_size = 0;
uint32 record_count = 0;
uint32 record_num;
uint32 record_pos;
uint32 key_size;
uint32 datalen_size;
uint32 datalen;
boolean bad_condition = FALSE;
if(p_store_item == NULL || access_info == NULL || key_info == NULL) {
FTA_LOG_MESSAGE(FTA_VAR, FTA_LOG_LEVEL_CRITICAL, "*** FTA VAR INTERNAL ERROR", 0, 0, 0);
return NULL;
}
FTA_ENTER_LOCK();
/* - - - - - - - - */
do {
if(access_info->lock_access) {
if(*p_store_item == NULL) {
bad_condition = TRUE;
break;
}
if((*p_store_item)->lock_keeper->manager_status != FTA_MANAGER_STATUS_ENABLED) {
bad_condition = TRUE;
break;
}
}
var_header = (fta_var_store_header *)((*p_store_item)->addr);
if(var_header->cmn.enabled != FTA_STORE_ENABLED_TRUE) {
bad_condition = TRUE;
break;
}
var_dataarea = FTA_LIB_OFFSET_ADDR(var_header, var_header->cmn.offset);
record_count = var_header->count;
dataarea_size = var_header->bottom;
} while(FALSE);
/* - - - - - - - - */
FTA_LEAVE_LOCK();
if(bad_condition) {
return var_record;
}
key_size = access_info->key_size;
datalen_size = access_info->datalen_size;
record_pos = 0;
/* - - - - - - - - */
for(record_num = 0; record_num < record_count; record_num++) {
if(dataarea_size < key_size + datalen_size + record_pos) {
var_record = NULL;
break;
}
var_record = (void *)FTA_LIB_OFFSET_ADDR(var_dataarea, record_pos);
if(memcmp(var_record, key_info, key_size) == 0) {
/* matched */
break;
}
datalen = 0;
if(datalen_size <= sizeof(uint32)) {
memcpy(&datalen, FTA_LIB_OFFSET_ADDR(var_record, key_size), datalen_size);
} else {
memcpy(&datalen, FTA_LIB_OFFSET_ADDR(var_record, key_size), sizeof(uint32));
}
var_record = NULL;
datalen = FTA_LIB_ALIGN4_32(datalen);
record_pos += key_size + datalen_size + datalen;
}
/* - - - - - - - - */
return var_record;
}
