/*********************************************************************************************************
** 函数名称: __ram_close
** 功能描述: ramfs 关闭一个文件
** 输 入 : pramn 文件节点
** iFlag 打开文件时的方法
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID __ram_close (PRAM_NODE pramn, INT iFlag)
{
pramn->RAMN_timeAccess = lib_time(LW_NULL);
if (pramn->RAMN_bChanged && ((iFlag & O_ACCMODE) != O_RDONLY)) {
pramn->RAMN_timeChange = pramn->RAMN_timeAccess;
}
}
/*********************************************************************************************************
** 函数名称: API_TimeShow
** 功能描述: 打印操作系统时间信息
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
API 函数
(不得在中断中调用)
*********************************************************************************************************/
LW_API
VOID API_TimeShow (VOID)
{
printf("time show >>\n\n");
printf("Kernel Ticks: %-63llu\n", API_TimeGet64());
#if LW_CFG_RTC_EN > 0
{
CHAR cTimeBuffer[32];
time_t time = lib_time(LW_NULL);
printf("%s", lib_ctime_r(&time, cTimeBuffer));
}
#else
printf("\n");
#endif /* LW_CFG_RTC_EN > 0 */
}
/*********************************************************************************************************
** 函数名称: uuidgen
** 功能描述: 获得 uuid
** 输 入 : uuidArray 保存数组
** iCnt 产生的数量
** 输 出 : 是否成功
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT uuidgen (uuid_t *uuidArray, INT iCnt)
{
time_t timeNow;
clock_t clock;
if (!uuidArray || (iCnt < 1) || (iCnt > 2048)) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
timeNow = lib_time(LW_NULL);
clock = lib_clock();
for (; iCnt > 0; iCnt--) {
__uuidGen(timeNow, clock, uuidArray);
uuidArray++;
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_RomFsDevCreate
** 功能描述: 创建 romfs 文件系统设备.
** 输 入 : pcName 设备名(设备挂接的节点地址)
** pblkd romfs 物理设备.
** 输 出 : < 0 表示失败
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_RomFsDevCreate (PCHAR pcName, PLW_BLK_DEV pblkd)
{
PROM_VOLUME promfs;
if (_G_iRomfsDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "romfs Driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
if ((pblkd == LW_NULL) || (pblkd->BLKD_pcName == LW_NULL)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "block device invalidate.\r\n");
_ErrorHandle(ERROR_IOS_DEVICE_NOT_FOUND);
return (PX_ERROR);
}
if ((pcName == LW_NULL) || __STR_IS_ROOT(pcName)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "mount name invalidate.\r\n");
_ErrorHandle(EFAULT); /* Bad address */
return (PX_ERROR);
}
promfs = (PROM_VOLUME)__SHEAP_ALLOC(sizeof(ROM_VOLUME));
if (promfs == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_bzero(promfs, sizeof(ROM_VOLUME)); /* 清空卷控制块 */
promfs->ROMFS_bValid = LW_TRUE;
promfs->ROMFS_hVolLock = API_SemaphoreMCreate("romvol_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_WAIT_FIFO | LW_OPTION_DELETE_SAFE |
LW_OPTION_INHERIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (!promfs->ROMFS_hVolLock) { /* 无法创建卷锁 */
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
promfs->ROMFS_pblkd = pblkd; /* 记录物理设备 */
promfs->ROMFS_ulSectorSize = pblkd->BLKD_ulBytesPerSector;
if (promfs->ROMFS_ulSectorSize == 0) {
if (pblkd->BLKD_pfuncBlkIoctl(pblkd,
LW_BLKD_GET_SECSIZE,
&promfs->ROMFS_ulSectorSize) < ERROR_NONE) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
}
promfs->ROMFS_ulSectorNum = pblkd->BLKD_ulNSector;
if (promfs->ROMFS_ulSectorNum == 0) {
if (pblkd->BLKD_pfuncBlkIoctl(pblkd,
LW_BLKD_GET_SECNUM,
&promfs->ROMFS_ulSectorNum) < ERROR_NONE) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
}
promfs->ROMFS_pcSector = (PCHAR)__SHEAP_ALLOC((size_t)promfs->ROMFS_ulSectorSize);
if (promfs->ROMFS_pcSector == LW_NULL) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
promfs->ROMFS_ulCurSector = (ULONG)-1; /* 当前窗口无效 */
if (__rfs_mount(promfs)) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs->ROMFS_pcSector);
__SHEAP_FREE(promfs);
_DebugHandle(__ERRORMESSAGE_LEVEL, "format unknown.\r\n");
_ErrorHandle(ERROR_IO_VOLUME_ERROR);
return (PX_ERROR);
}
promfs->ROMFS_uid = getuid();
promfs->ROMFS_gid = getgid();
lib_time(&promfs->ROMFS_time); /* 获得当前时间 */
if (iosDevAddEx(&promfs->ROMFS_devhdrHdr, pcName, _G_iRomfsDrvNum, DT_DIR)
!= ERROR_NONE) { /* 安装文件系统设备 */
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs->ROMFS_pcSector);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
__fsDiskLinkCounterAdd(pblkd); /* 增加块设备链接 */
_DebugFormat(__LOGMESSAGE_LEVEL, "target \"%s\" mount ok.\r\n", pcName);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __ram_maken
** 功能描述: ramfs 创建一个文件
** 输 入 : pramfs 文件系统
** pcName 文件名
** pramnFather 父亲, NULL 表示根目录
** mode mode_t
** pcLink 如果为连接文件, 这里指明连接目标.
** 输 出 : 创建结果
** 全局变量:
** 调用模块:
*********************************************************************************************************/
PRAM_NODE __ram_maken (PRAM_VOLUME pramfs,
CPCHAR pcName,
PRAM_NODE pramnFather,
mode_t mode,
CPCHAR pcLink)
{
PRAM_NODE pramn = (PRAM_NODE)__SHEAP_ALLOC(sizeof(RAM_NODE));
CPCHAR pcFileName;
if (pramn == LW_NULL) {
_ErrorHandle(ENOMEM);
return (LW_NULL);
}
lib_bzero(pramn, sizeof(RAM_NODE));
pcFileName = lib_rindex(pcName, PX_DIVIDER);
if (pcFileName) {
pcFileName++;
} else {
pcFileName = pcName;
}
pramn->RAMN_pcName = (PCHAR)__SHEAP_ALLOC(lib_strlen(pcFileName) + 1);
if (pramn->RAMN_pcName == LW_NULL) {
__SHEAP_FREE(pramn);
_ErrorHandle(ENOMEM);
return (LW_NULL);
}
lib_strcpy(pramn->RAMN_pcName, pcFileName);
if (S_ISLNK(mode)) {
pramn->RAMN_pcLink = (PCHAR)__SHEAP_ALLOC(lib_strlen(pcLink) + 1);
if (pramn->RAMN_pcLink == LW_NULL) {
__SHEAP_FREE(pramn->RAMN_pcName);
__SHEAP_FREE(pramn);
_ErrorHandle(ENOMEM);
return (LW_NULL);
}
lib_strcpy(pramn->RAMN_pcLink, pcLink);
} else {
if ((mode & S_IFMT) == 0) {
mode |= S_IFREG;
}
pramn->RAMN_pcLink = LW_NULL;
}
pramn->RAMN_pramnFather = pramnFather;
pramn->RAMN_pramfs = pramfs;
pramn->RAMN_mode = mode;
pramn->RAMN_timeCreate = lib_time(LW_NULL);
pramn->RAMN_timeAccess = pramn->RAMN_timeCreate;
pramn->RAMN_timeChange = pramn->RAMN_timeCreate;
pramn->RAMN_uid = getuid();
pramn->RAMN_gid = getgid();
pramn->RAMN_prambCookie = LW_NULL;
if (pramnFather) {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramnFather->RAMN_plineSon);
} else {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramfs->RAMFS_plineSon);
}
return (pramn);
}
/*********************************************************************************************************
** 函数名称: API_PipeDevCreate
** 功能描述: 创建一个管道设备
** 输 入 :
** pcName 管道名称
** ulNMessages 管道中消息数量
** stNBytes 每一条消息的最大字节数
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_PipeDevCreate (PCHAR pcName,
ULONG ulNMessages,
size_t stNBytes)
{
REGISTER PLW_PIPE_DEV p_pipedev;
if (LW_CPU_GET_CUR_NESTING()) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (PX_ERROR);
}
if (_G_iPipeDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
p_pipedev = (PLW_PIPE_DEV)__SHEAP_ALLOC(sizeof(LW_PIPE_DEV));
if (p_pipedev == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_bzero(p_pipedev, sizeof(LW_PIPE_DEV));
p_pipedev->PIPEDEV_iAbortFlag = 0;
p_pipedev->PIPEDEV_ulRTimeout = LW_OPTION_WAIT_INFINITE; /* 初始化为永久等待 */
p_pipedev->PIPEDEV_ulWTimeout = LW_OPTION_WAIT_INFINITE; /* 初始化为永久等待 */
p_pipedev->PIPEDEV_hWriteLock = API_SemaphoreBCreate("pipe_wsync",
LW_TRUE,
_G_ulPipeLockOpt | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (!p_pipedev->PIPEDEV_hWriteLock) {
__SHEAP_FREE((PVOID)p_pipedev);
return (PX_ERROR);
}
p_pipedev->PIPEDEV_hMsgQueue = API_MsgQueueCreate("pipe_msg",
ulNMessages, stNBytes,
_G_ulPipeLockOpt | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (!p_pipedev->PIPEDEV_hMsgQueue) {
API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
__SHEAP_FREE((PVOID)p_pipedev);
return (PX_ERROR);
}
SEL_WAKE_UP_LIST_INIT(&p_pipedev->PIPEDEV_selwulList);
if (iosDevAddEx(&p_pipedev->PIPEDEV_devhdrHdr, pcName, _G_iPipeDrvNum, DT_FIFO) != ERROR_NONE) {
API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
API_MsgQueueDelete(&p_pipedev->PIPEDEV_hMsgQueue);
SEL_WAKE_UP_LIST_TERM(&p_pipedev->PIPEDEV_selwulList);
__SHEAP_FREE((PVOID)p_pipedev);
_DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
p_pipedev->PIPEDEV_timeCreate = lib_time(LW_NULL);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: syslog_r
** 功能描述: submits a message to the Syslog facility. It does this by writing to the file (支持不完整)
LOG_DEFAULT_FILE
** 输 入 : priority priority
** data syslog_data
** message message
...
** 输 出 : old mask
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
void syslog_r (int priority, struct syslog_data *data, const char *message, ...)
{
#define __PX_SYSLOG_TIMEFMT "%s %2d %02d:%02d:%02d"
CHAR cBuffer[LOG_DEFAULT_SIZE];
size_t stLen;
time_t time;
struct tm tmBuf;
va_list valist;
if (!data) {
errno = EINVAL;
return;
}
if (((unsigned)LOG_FAC(priority) >= LOG_NFACILITIES) ||
(LOG_MASK(LOG_PRI(priority)) == 0) ||
((priority & ~(LOG_PRIMASK | LOG_FACMASK)) != 0)) {
return; /* 不发送 */
}
if ((data->log_file < 0) && (data->log_stat & LOG_ODELAY)) { /* 是否需要执行一次打开操作 */
openlog(data->log_tag, data->log_file, 0);
data->log_file = _G_iSyslogUnix;
}
if ((priority & LOG_FACMASK) == 0) {
priority |= data->log_fac;
}
time = lib_time(LW_NULL);
lib_localtime_r(&time, &tmBuf); /* RFC3164 is the local time */
stLen = bnprintf(cBuffer, sizeof(cBuffer), 0, "<%d>", priority); /* 打印 priority */
stLen = bnprintf(cBuffer, sizeof(cBuffer), stLen,
__PX_SYSLOG_TIMEFMT,
_G_cMonth[tmBuf.tm_mon],
tmBuf.tm_mday,
tmBuf.tm_hour,
tmBuf.tm_min,
tmBuf.tm_sec); /* 打印 时间 */
if (data->log_tag) {
stLen = bnprintf(cBuffer, sizeof(cBuffer), stLen, " %s", data->log_tag);
}
if (data->log_stat & LOG_PID) {
if (sizeof(cBuffer) > stLen) {
stLen = bnprintf(cBuffer, sizeof(cBuffer), stLen, "[%lx]:",
API_ThreadIdSelf());
}
}
if (message) {
if (sizeof(cBuffer) > stLen) {
#if __STDC__
va_start(valist, message);
#else
va_start(valist);
#endif
stLen = vbnprintf(cBuffer, sizeof(cBuffer), stLen, message, valist);
va_end(valist);
}
}
if (data->log_file >= 0) {
sendto(data->log_file, cBuffer, stLen, 0,
(struct sockaddr *)&_G_sockaddrunLog, _G_sockelenLog);
}
if (data->log_stat & LOG_CONS) {
write(STD_OUT, cBuffer, stLen);
}
if (data->log_stat & LOG_PERROR) {
write(STD_ERR, cBuffer, stLen);
}
}
