|
|
/* Includes ------------------------------------------------------------------*/
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
#include "config.h"
|
|
|
#endif
|
|
|
|
|
|
/* 标准C库头文件. */
|
|
|
#include <sys/types.h>
|
|
|
#include <sys/ipc.h>
|
|
|
#include <sys/msg.h>
|
|
|
#include <sys/stat.h>
|
|
|
#include <sys/socket.h>
|
|
|
#include <fcntl.h>
|
|
|
#include <netinet/in.h>
|
|
|
#include <arpa/inet.h>
|
|
|
#include <pthread.h>
|
|
|
#include <dirent.h>
|
|
|
|
|
|
/* 用户代码头文件. */
|
|
|
#include "cmd.h"
|
|
|
#include "fifo.h"
|
|
|
#include "pd_main.h"
|
|
|
#include "pd_dau.h"
|
|
|
#include "pd_storage.h"
|
|
|
|
|
|
/* Private define ------------------------------------------------------------*/
|
|
|
#define STORAGE_PATH "/run/media/mmcblk1p3/Data"
|
|
|
#define STORAGE_PATH_EVENT "/run/media/mmcblk1p3/Data/Event"
|
|
|
#define STORAGE_PATH_TREND "/run/media/mmcblk1p3/Data/Trend"
|
|
|
#define STORAGE_PATH_FIXEDTIMEPRPS "/run/media/mmcblk1p3/Data/FixedTimePRPS"
|
|
|
|
|
|
#define DEL_FILE_RATE_DEFAULT 10
|
|
|
|
|
|
/* Private macro -------------------------------------------------------------*/
|
|
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
|
|
|
|
/* Private variables ---------------------------------------------------------*/
|
|
|
storage_t storage;
|
|
|
storage_arg_t storage_arg;
|
|
|
|
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
|
|
|
|
|
|
|
/* Internal functions --------------------------------------------------------*/
|
|
|
|
|
|
/* 以“wb”方式覆盖写入二进制文件 */
|
|
|
int32_t _storage_write_hex_file( const char *file_name, uint8_t *data, uint32_t len)
|
|
|
{
|
|
|
if (file_name == NULL || data == NULL || len < 1)
|
|
|
{
|
|
|
log_err( LOG_STORAGE, "Write file %s param ERROR!", file_name );
|
|
|
return E_BAD_PARAM;
|
|
|
}
|
|
|
|
|
|
usleep(1000);
|
|
|
FILE *file = fopen( file_name, "wb" );
|
|
|
if (file == NULL)
|
|
|
{
|
|
|
log_err( LOG_STORAGE, "Write file %s ERROR!", file_name );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
usleep(1000);
|
|
|
|
|
|
int32_t bytes_cnt;
|
|
|
bytes_cnt = fwrite( data, len, 1, file );
|
|
|
fclose( file );
|
|
|
return bytes_cnt;
|
|
|
}
|
|
|
|
|
|
/* 将文件名解析为UTC索引号 */
|
|
|
uint32_t _storage_filename_parse_utc( char *file_name )
|
|
|
{
|
|
|
uint32_t file_utc;
|
|
|
char date[FILE_NAME_LEN] = {0};
|
|
|
char time[FILE_NAME_LEN] = {0};
|
|
|
|
|
|
strncpy( date, file_name, 10 );
|
|
|
strncpy( time, file_name + 11, 8 );
|
|
|
|
|
|
time_str_to_long( date, time, &file_utc);
|
|
|
|
|
|
return file_utc;
|
|
|
}
|
|
|
|
|
|
/* 以UTC时间作为文件名 */
|
|
|
int32_t _storage_set_filename( char *file_name, uint32_t file_utc )
|
|
|
{
|
|
|
char time_str[FILE_NAME_LEN];
|
|
|
|
|
|
time_t file_time = file_utc;
|
|
|
struct tm *lt = localtime( &file_time );
|
|
|
|
|
|
strftime( time_str, FILE_NAME_LEN, "%Y-%m-%d %H:%M:%S", lt );
|
|
|
snprintf( file_name, FILE_NAME_LEN, "%s.dat", time_str );
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 根据UTC的最大、最小值以及比重参数rate确定UTC基准值，UTC小于该基准值的文件将被删除 */
|
|
|
uint32_t _storage_get_utc_base( uint32_t max_utc, uint32_t min_utc, int rate)
|
|
|
{
|
|
|
uint32_t utc_base;
|
|
|
utc_base = (max_utc - min_utc) / rate + min_utc;
|
|
|
return utc_base;
|
|
|
}
|
|
|
|
|
|
/* 创建存储文件夹 */
|
|
|
int32_t _storage_create_dir( void )
|
|
|
{
|
|
|
uint8_t unit;
|
|
|
uint8_t port;
|
|
|
char dir_path[DIR_PATH_LEN] = {0};
|
|
|
|
|
|
/* 创建父文件夹 */
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
{
|
|
|
switch( i )
|
|
|
{
|
|
|
case 0:
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s", STORAGE_PATH );
|
|
|
break;
|
|
|
case 1:
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s", STORAGE_PATH_EVENT );
|
|
|
break;
|
|
|
case 2:
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s", STORAGE_PATH_TREND );
|
|
|
break;
|
|
|
case 3:
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s", STORAGE_PATH_FIXEDTIMEPRPS );
|
|
|
break;
|
|
|
default:
|
|
|
return E_NONE;
|
|
|
}
|
|
|
if( access( dir_path, 0 ) == -1 )
|
|
|
{
|
|
|
if (mkdir( dir_path, 0777 ))
|
|
|
{
|
|
|
log_err( LOG_STORAGE, "Create storage DIR %s failed!", dir_path );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* 创建事件数据通道子文件夹 */
|
|
|
for (unit = 0; unit < PD_DAU_SUM; unit++)
|
|
|
{
|
|
|
for (port = 0; port < PD_DAU_PORT_SUM; port++)
|
|
|
{
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s/%02d", STORAGE_PATH_EVENT, (unit * PD_DAU_PORT_SUM + port + 1) );
|
|
|
if( access( dir_path, 0 ) == -1 )
|
|
|
{
|
|
|
if (mkdir( dir_path, 0777 ))
|
|
|
{
|
|
|
log_err( LOG_STORAGE, "Create storage DIR %s failed!", dir_path );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 遍历文件夹以获得最小UTC值与文件数量 */
|
|
|
int32_t _storage_get_min_utc_file_cnt( char *dir_path, uint32_t *min_utc, uint16_t *file_count )
|
|
|
{
|
|
|
*file_count = 0;
|
|
|
*min_utc = time(NULL);
|
|
|
|
|
|
if (access( dir_path, 0 ) == -1) //文件夹不存在
|
|
|
{
|
|
|
if (mkdir( dir_path, 0777 ))
|
|
|
{
|
|
|
log_err( LOG_STORAGE, "Create storage DIR %s failed!", dir_path );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
DIR *dir;
|
|
|
struct dirent *ptr;
|
|
|
uint32_t file_utc = 0;
|
|
|
|
|
|
if( (dir = opendir( dir_path )) == NULL )
|
|
|
{
|
|
|
log_err( LOG_STORAGE, "ERROR! Can't open dir %s to get param!", dir_path );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
while( (ptr = readdir( dir )) != NULL )
|
|
|
{
|
|
|
if (ptr->d_type == DT_REG) //常规文件
|
|
|
{
|
|
|
file_utc = _storage_filename_parse_utc( ptr->d_name );
|
|
|
if (*min_utc > file_utc)
|
|
|
{
|
|
|
*min_utc = file_utc;
|
|
|
}
|
|
|
(*file_count)++;
|
|
|
}
|
|
|
}
|
|
|
closedir( dir );
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 存储参数初始化，包括已存储文件数，UTC的最小值等 */
|
|
|
int32_t _storage_arg_init( void )
|
|
|
{
|
|
|
/* 事件存储参数初始化 */
|
|
|
uint8_t unit;
|
|
|
uint8_t port;
|
|
|
for (unit = 0; unit < PD_DAU_SUM; unit++)
|
|
|
{
|
|
|
for (port = 0; port < PD_DAU_PORT_SUM; port++)
|
|
|
{
|
|
|
/* 判断事件频繁参数初始化 */
|
|
|
storage_arg.utc_base[unit][port] = time(NULL);
|
|
|
storage_arg.limit_cnt[unit][port] = pd_config.config.limit_event_cnt;
|
|
|
|
|
|
char dir_path[DIR_PATH_LEN] = {0};
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s/%02d", STORAGE_PATH_EVENT, (unit * PD_DAU_PORT_SUM + port + 1) );
|
|
|
_storage_get_min_utc_file_cnt( dir_path, &storage_arg.event_min_utc[unit][port], &storage_arg.event_cnt[unit][port] );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* 趋势存储参数初始化 */
|
|
|
_storage_get_min_utc_file_cnt( STORAGE_PATH_TREND, &storage_arg.trend_min_utc, &storage_arg.trend_cnt );
|
|
|
|
|
|
/* 定时存储参数初始化 */
|
|
|
_storage_get_min_utc_file_cnt( STORAGE_PATH_FIXEDTIMEPRPS, &storage_arg.fixedtimePRPS_min_utc, &storage_arg.fixedtimePRPS_cnt );
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 运行中无法访问文件夹，说明文件夹可能被删除，重新创建 */
|
|
|
int32_t _storage_recreate_dir( char *dir_path )
|
|
|
{
|
|
|
/* 若创建不成功，说明父文件夹可能被删除，此时从父文件夹开始创建并重新初始化参数 */
|
|
|
if (mkdir( dir_path, 0777 ))
|
|
|
{
|
|
|
_storage_create_dir();
|
|
|
_storage_arg_init();
|
|
|
return E_NONE;
|
|
|
}
|
|
|
return TRUE; //表示文件夹创建成功
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @brief 删除文件函数
|
|
|
* @param *dir_path: 进行删除操作的文件夹
|
|
|
* @param utc_base: UTC基准值，UTC小于等于该值的文件将被删除
|
|
|
* @param *min_utc: 引用全局变量，最小UTC值，最终结果为文件夹剩余文件中的最小UTC值
|
|
|
* @param *file_count: 引用全局变量，文件总数，最终结果为文件夹中剩余文件数量
|
|
|
*/
|
|
|
int32_t _storage_delete_file( char *dir_path, uint32_t utc_base, uint32_t *min_utc, uint16_t *file_count )
|
|
|
{
|
|
|
DIR *dir;
|
|
|
struct dirent *ptr;
|
|
|
char remove_path[DIR_PATH_LEN]; //删除文件的路径
|
|
|
int remove_ret; //remove函数的返回值
|
|
|
uint32_t file_utc;
|
|
|
*min_utc = time(NULL);
|
|
|
|
|
|
if( (dir = opendir( dir_path )) == NULL )
|
|
|
{
|
|
|
log_err( LOG_STORAGE, "ERROR! Can't open delete dir %s !", dir_path );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
while( (ptr = readdir( dir )) != NULL )
|
|
|
{
|
|
|
if (ptr->d_type == DT_REG) //常规文件
|
|
|
{
|
|
|
file_utc = _storage_filename_parse_utc( ptr->d_name );
|
|
|
|
|
|
if( (file_utc > utc_base) && (file_utc < *min_utc) )
|
|
|
{
|
|
|
*min_utc = file_utc;
|
|
|
}
|
|
|
|
|
|
if (file_utc <= utc_base) //需要被删除的文件
|
|
|
{
|
|
|
memset( remove_path, '\0', sizeof(remove_path) );
|
|
|
strcpy( remove_path, dir_path );
|
|
|
strcat( remove_path, "/" );
|
|
|
strcat( remove_path, ptr->d_name );
|
|
|
|
|
|
remove_ret = remove( remove_path );
|
|
|
if (remove_ret == 0) //成功删除，文件总数减一
|
|
|
{
|
|
|
(*file_count)--;
|
|
|
}
|
|
|
else if (remove_ret == -1)
|
|
|
{
|
|
|
log_warn( LOG_STORAGE, "WARN! Remove file %s failed!", ptr->d_name );
|
|
|
|
|
|
if (errno == EROFS)
|
|
|
{
|
|
|
printf( "File Only Read\r\n" );
|
|
|
}
|
|
|
else if (errno == EFAULT)
|
|
|
{
|
|
|
printf( "File Pointer to the overflow\r\n" );
|
|
|
}
|
|
|
else if (errno == ENAMETOOLONG)
|
|
|
{
|
|
|
printf( "File Name Over Long\r\n" );
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
closedir( dir );
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 判断时间存储是否过于频繁，返回E_NONE代表将存储该文件 */
|
|
|
int32_t _storage_event_frequently( uint32_t utc, uint8_t unit, uint8_t port )
|
|
|
{
|
|
|
/* 周期结束，判断是否频繁存储 */
|
|
|
if( storage_arg.limit_cnt[unit][port] <= 0 )
|
|
|
{
|
|
|
/* 上周期存储频繁，间隔存储直到限制时间到达 */
|
|
|
if( utc < (storage_arg.utc_base[unit][port] + pd_config.config.limit_event_time) )
|
|
|
{
|
|
|
/* 间隔存储 */
|
|
|
if( utc < (storage_arg.event_max_utc[unit][port] + pd_config.config.limit_event_interval) )
|
|
|
{
|
|
|
return E_TIMEOUT;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return E_NONE;
|
|
|
}
|
|
|
}
|
|
|
/* 间隔存储限时结束或上周期存储不频繁 */
|
|
|
else
|
|
|
{
|
|
|
storage_arg.limit_cnt[unit][port] = pd_config.config.limit_event_cnt - 1;
|
|
|
storage_arg.utc_base[unit][port] = utc;
|
|
|
return E_NONE;
|
|
|
}
|
|
|
}
|
|
|
/* 周期未结束 */
|
|
|
storage_arg.limit_cnt[unit][port]--;
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 事件文件存储函数 */
|
|
|
int32_t _storage_event( pd_event_t *data )
|
|
|
{
|
|
|
uint8_t unit;
|
|
|
uint8_t port;
|
|
|
dau_vport_to_port( data->vport, &unit, &port );
|
|
|
|
|
|
if (_storage_event_frequently( data->utc, unit, port ))
|
|
|
{
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
int32_t bytes_cnt;
|
|
|
char file_name[FILE_NAME_LEN];
|
|
|
char dir_path[DIR_PATH_LEN];
|
|
|
char dir_file_write[DIR_PATH_LEN];
|
|
|
|
|
|
_storage_set_filename( file_name, data->utc );
|
|
|
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s/%02d", STORAGE_PATH_EVENT, data->vport );
|
|
|
if (access( dir_path, 0 ) == -1) //文件夹不存在或被删除
|
|
|
{
|
|
|
if (_storage_recreate_dir( dir_path ))
|
|
|
{
|
|
|
storage_arg.event_min_utc[unit][port] = data->utc;
|
|
|
storage_arg.event_cnt[unit][port] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
snprintf( dir_file_write, DIR_PATH_LEN, "%s/%s", dir_path, file_name );
|
|
|
bytes_cnt = _storage_write_hex_file( dir_file_write, (uint8_t*) data, sizeof(pd_event_t) );
|
|
|
if (bytes_cnt < 0)
|
|
|
{
|
|
|
DBG( DBG_M_STORAGE_ERR, "Local storage return %s!\r\n", safe_strerror(errno) );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
storage_arg.event_max_utc[unit][port] = data->utc;
|
|
|
storage_arg.event_cnt[unit][port]++;
|
|
|
if (storage_arg.event_cnt[unit][port] >= pd_config.port_config[unit][port].config.storage_event)
|
|
|
{
|
|
|
_storage_delete_file( dir_path,
|
|
|
_storage_get_utc_base( storage_arg.event_max_utc[unit][port], storage_arg.event_min_utc[unit][port], DEL_FILE_RATE_DEFAULT ),
|
|
|
&storage_arg.event_min_utc[unit][port],
|
|
|
&storage_arg.event_cnt[unit][port] );
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 趋势文件存储函数 */
|
|
|
int32_t _storage_trend( pd_trend_t *data )
|
|
|
{
|
|
|
int32_t bytes_cnt;
|
|
|
char file_name[FILE_NAME_LEN];
|
|
|
char dir_path[DIR_PATH_LEN];
|
|
|
char dir_file_write[DIR_PATH_LEN];
|
|
|
|
|
|
_storage_set_filename( file_name, data->utc );
|
|
|
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s", STORAGE_PATH_TREND );
|
|
|
if (access( dir_path, 0 ) == -1) //文件夹不存在
|
|
|
{
|
|
|
if (_storage_recreate_dir( dir_path ))
|
|
|
{
|
|
|
storage_arg.trend_min_utc = data->utc;
|
|
|
storage_arg.trend_cnt = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
snprintf( dir_file_write, DIR_PATH_LEN, "%s/%s", dir_path, file_name );
|
|
|
bytes_cnt = _storage_write_hex_file( dir_file_write, (uint8_t*) data, sizeof(pd_trend_t) );
|
|
|
if (bytes_cnt < 0)
|
|
|
{
|
|
|
DBG( DBG_M_STORAGE_ERR, "Local storage return %s!\r\n", safe_strerror(errno) );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
storage_arg.trend_max_utc = data->utc;
|
|
|
storage_arg.trend_cnt++;
|
|
|
if (storage_arg.trend_cnt >= pd_config.config.storage_trend)
|
|
|
{
|
|
|
_storage_delete_file( dir_path,
|
|
|
_storage_get_utc_base( storage_arg.trend_max_utc, storage_arg.trend_min_utc, DEL_FILE_RATE_DEFAULT ),
|
|
|
&storage_arg.trend_min_utc,
|
|
|
&storage_arg.trend_cnt );
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 定时PRPS文件存储函数 */
|
|
|
int32_t _storage_fixedtimePRPS( pd_prps_t *data )
|
|
|
{
|
|
|
int32_t bytes_cnt;
|
|
|
char file_name[FILE_NAME_LEN];
|
|
|
char dir_path[DIR_PATH_LEN];
|
|
|
char dir_file_write[DIR_PATH_LEN];
|
|
|
|
|
|
_storage_set_filename( file_name, data->utc );
|
|
|
|
|
|
snprintf( dir_path, DIR_PATH_LEN, "%s", STORAGE_PATH_FIXEDTIMEPRPS );
|
|
|
if (access( dir_path, 0 ) == -1) //文件夹不存在
|
|
|
{
|
|
|
if (_storage_recreate_dir( dir_path ))
|
|
|
{
|
|
|
storage_arg.fixedtimePRPS_min_utc = data->utc;
|
|
|
storage_arg.fixedtimePRPS_cnt = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
snprintf( dir_file_write, DIR_PATH_LEN, "%s/%s", dir_path, file_name );
|
|
|
bytes_cnt = _storage_write_hex_file( dir_file_write, (uint8_t*) data, sizeof(pd_prps_t) );
|
|
|
if (bytes_cnt < 0)
|
|
|
{
|
|
|
DBG( DBG_M_STORAGE_ERR, "Local storage return %s!\r\n", safe_strerror(errno) );
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
storage_arg.fixedtimePRPS_max_utc = data->utc;
|
|
|
storage_arg.fixedtimePRPS_cnt++;
|
|
|
if (storage_arg.fixedtimePRPS_cnt >= pd_config.config.storage_real)
|
|
|
{
|
|
|
_storage_delete_file( dir_path,
|
|
|
_storage_get_utc_base( storage_arg.fixedtimePRPS_max_utc, storage_arg.fixedtimePRPS_min_utc, DEL_FILE_RATE_DEFAULT ),
|
|
|
&storage_arg.fixedtimePRPS_min_utc,
|
|
|
&storage_arg.fixedtimePRPS_cnt );
|
|
|
}
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 本地存储处理句柄 */
|
|
|
void *_local_storage_handle(void *arg)
|
|
|
{
|
|
|
pd_storage_msg_t *recv_msg = NULL;
|
|
|
|
|
|
while(1)
|
|
|
{
|
|
|
if(fifo_read(storage.storage_fifo_id,(void **)&recv_msg) != 0)
|
|
|
{
|
|
|
DBG(DBG_M_STORAGE_ERR,"ERROR at fifo %d read!\r\n",storage.storage_fifo_id);
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
/* 数据存储处理 */
|
|
|
switch(recv_msg->type)
|
|
|
{
|
|
|
case STORAGE_TYPE_EVENT:
|
|
|
_storage_event( (pd_event_t*) recv_msg->data );
|
|
|
break;
|
|
|
case STORAGE_TYPE_TREND:
|
|
|
_storage_trend( (pd_trend_t*) recv_msg->data );
|
|
|
break;
|
|
|
case STORAGE_TYPE_ALARM:
|
|
|
break;
|
|
|
case STORAGE_TYPE_RUNSTATUS:
|
|
|
break;
|
|
|
case STORAGE_TYPE_FIXEDTIMERPRPS:
|
|
|
_storage_fixedtimePRPS( (pd_prps_t*) recv_msg->data );
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
/* 释放存储数据内存 */
|
|
|
XFREE(MTYPE_STORAGE,recv_msg->data);
|
|
|
fifo_push(storage.storage_fifo_id);
|
|
|
}
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
/* 本地存储公共部分初始化 */
|
|
|
int32_t _local_storage_init_common(void)
|
|
|
{
|
|
|
struct sched_param param;
|
|
|
pthread_attr_t attr;
|
|
|
pthread_t pid;
|
|
|
int rv = 0;
|
|
|
|
|
|
_storage_create_dir();
|
|
|
_storage_arg_init();
|
|
|
|
|
|
storage.storage_fifo_id = fifo_create(STORAGE_DATA_FIFO, 32);
|
|
|
if(storage.storage_fifo_id < 0)
|
|
|
{
|
|
|
log_err(LOG_STORAGE,"Open fifo " STORAGE_DATA_FIFO " error!");
|
|
|
return E_ERROR;
|
|
|
}
|
|
|
|
|
|
pthread_mutex_init(&storage.mutex, NULL);
|
|
|
|
|
|
/* 配置线程RR调度，优先级50 */
|
|
|
pthread_attr_init(&attr);
|
|
|
param.sched_priority = 50;
|
|
|
pthread_attr_setschedpolicy(&attr, SCHED_RR);
|
|
|
pthread_attr_setschedparam(&attr, ¶m);
|
|
|
pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
|
|
|
rv = pthread_create(&pid, &attr, _local_storage_handle, NULL);
|
|
|
if(rv != 0)
|
|
|
{
|
|
|
log_err(LOG_STORAGE, "PD can't create storage pthread %d!", rv);
|
|
|
return E_SYS_CALL;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
thread_m_add("LOCAL_STORAGE", pid);
|
|
|
}
|
|
|
pthread_attr_destroy(&attr);
|
|
|
|
|
|
return E_NONE;
|
|
|
}
|
|
|
|
|
|
/* 本地存储模块初始化 */
|
|
|
int32_t localstorage_handle_init(void)
|
|
|
{
|
|
|
/* 初始化模块 */
|
|
|
LD_E_RETURN(DBG_M_STORAGE_ERR,_local_storage_init_common());
|
|
|
return E_NONE;
|
|
|
}
|
|
|
/************************ (C) COPYRIGHT LandPower ***** END OF FILE ****************/ |