/*********************************************************************************************************
** 函数名称: API_InterVectorGetFlag
** 功能描述: 获得指定中断向量的特性.
** 输 入 : ulVector 中断向量号
** *pulFlag 特性
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_InterVectorGetFlag (ULONG ulVector, ULONG *pulFlag)
{
INTREG iregInterLevel;
PLW_CLASS_INTDESC pidesc;
if (_Inter_Vector_Invalid(ulVector)) {
_ErrorHandle(ERROR_KERNEL_VECTOR_NULL);
return (ERROR_KERNEL_VECTOR_NULL);
}
if (!pulFlag) {
_ErrorHandle(ERROR_KERNEL_MEMORY);
return (ERROR_KERNEL_MEMORY);
}
pidesc = LW_IVEC_GET_IDESC(ulVector);
LW_SPIN_LOCK_QUICK(&pidesc->IDESC_slLock, &iregInterLevel); /* 关闭中断同时锁住 spinlock */
*pulFlag = LW_IVEC_GET_FLAG(ulVector);
LW_SPIN_UNLOCK_QUICK(&pidesc->IDESC_slLock, iregInterLevel); /* 打开中断, 同时打开 spinlock */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: if_up
** 功能描述: 打开网卡
** 输 入 : ifname if name
** 输 出 : 网卡是否打开
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT if_up (const char *ifname)
{
INT iError;
struct netif *pnetif;
LWIP_NETIF_LOCK(); /* 进入临界区 */
pnetif = netif_find((char *)ifname);
if (pnetif) {
if (!(pnetif->flags & NETIF_FLAG_UP)) {
netifapi_netif_set_up(pnetif);
#if LWIP_DHCP > 0
if (pnetif->flags2 & NETIF_FLAG2_DHCP) {
ip_addr_t inaddrNone;
lib_bzero(&inaddrNone, sizeof(ip_addr_t));
netifapi_netif_set_addr(pnetif, &inaddrNone, &inaddrNone, &inaddrNone);
netifapi_dhcp_start(pnetif);
}
#endif /* LWIP_DHCP > 0 */
iError = ERROR_NONE;
} else {
_ErrorHandle(EALREADY);
iError = PX_ERROR;
}
} else {
_ErrorHandle(ENXIO);
iError = PX_ERROR;
}
LWIP_NETIF_UNLOCK(); /* 退出临界区 */
return (iError);
}
/*********************************************************************************************************
** 函数名称: if_down
** 功能描述: 关闭网卡
** 输 入 : ifname if name
** 输 出 : 关闭是否成功
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT if_down (const char *ifname)
{
INT iError;
struct netif *pnetif;
LWIP_NETIF_LOCK(); /* 进入临界区 */
pnetif = netif_find((char *)ifname);
if (pnetif) {
if (pnetif->flags & NETIF_FLAG_UP) {
#if LWIP_DHCP > 0
if (pnetif->dhcp && pnetif->dhcp->pcb) {
netifapi_netif_common(pnetif, NULL, dhcp_release); /* 解除 DHCP 租约, 同时停止网卡*/
netifapi_dhcp_stop(pnetif); /* 释放资源 */
}
#endif /* LWIP_DHCP > 0 */
netifapi_netif_set_down(pnetif); /* 禁用网卡 */
iError = ERROR_NONE;
} else {
_ErrorHandle(EALREADY);
iError = PX_ERROR;
}
} else {
_ErrorHandle(ENXIO);
iError = PX_ERROR;
}
LWIP_NETIF_UNLOCK(); /* 退出临界区 */
return (iError);
}
/*********************************************************************************************************
** 函数名称: if_set_dhcp
** 功能描述: 设置网卡 dhcp 选项 (必须在网卡禁能时设置)
** 输 入 : ifname if name
** en 1: 使能 dhcp 0: 禁能 dhcp
** 输 出 : OK or ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT if_set_dhcp (const char *ifname, int en)
{
INT iRet = PX_ERROR;
#if LWIP_DHCP > 0
struct netif *pnetif;
LWIP_NETIF_LOCK(); /* 进入临界区 */
pnetif = netif_find((char *)ifname);
if (pnetif) {
if (pnetif->flags & NETIF_FLAG_UP) {
_ErrorHandle(EISCONN);
} else {
if (en) {
pnetif->flags2 |= NETIF_FLAG2_DHCP;
} else {
pnetif->flags2 &= ~NETIF_FLAG2_DHCP;
}
iRet = ERROR_NONE;
}
} else {
_ErrorHandle(ENXIO);
}
LWIP_NETIF_UNLOCK(); /* 退出临界区 */
#else
_ErrorHandle(ENOSYS);
#endif /* LWIP_DHCP > 0 */
return (iRet);
}
/*********************************************************************************************************
** 函数名称: API_InterVectorDisconnect
** 功能描述: 解除系统指定向量中断服务
** 输 入 : ulVector 中断向量号
** pfuncIsr 服务函数
** pvArg 服务函数参数
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_InterVectorDisconnect (ULONG ulVector,
PINT_SVR_ROUTINE pfuncIsr,
PVOID pvArg)
{
INTREG iregInterLevel;
BOOL bNeedFree = LW_FALSE;
PLW_LIST_LINE plineTemp;
PLW_CLASS_INTACT piaction;
PLW_CLASS_INTDESC pidesc;
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (ERROR_KERNEL_IN_ISR);
}
INTER_SHOWLOCK_CREATE();
if (_Inter_Vector_Invalid(ulVector)) {
_ErrorHandle(ERROR_KERNEL_VECTOR_NULL);
return (ERROR_KERNEL_VECTOR_NULL);
}
if (pfuncIsr == LW_NULL) {
_ErrorHandle(ERROR_KERNEL_VECTOR_NULL);
return (ERROR_KERNEL_VECTOR_NULL);
}
INTER_SHOWLOCK_LOCK();
pidesc = LW_IVEC_GET_IDESC(ulVector);
LW_SPIN_LOCK_QUICK(&pidesc->IDESC_slLock, &iregInterLevel); /* 关闭中断同时锁住 spinlock */
for (plineTemp = pidesc->IDESC_plineAction;
plineTemp != LW_NULL;
plineTemp = _list_line_get_next(plineTemp)) {
piaction = _LIST_ENTRY(plineTemp, LW_CLASS_INTACT, IACT_plineManage);
if ((piaction->IACT_pfuncIsr == pfuncIsr) &&
(piaction->IACT_pvArg == pvArg)) {
_List_Line_Del(&piaction->IACT_plineManage,
&pidesc->IDESC_plineAction);
bNeedFree = LW_TRUE;
break;
}
}
LW_SPIN_UNLOCK_QUICK(&pidesc->IDESC_slLock, iregInterLevel); /* 打开中断, 同时打开 spinlock */
INTER_SHOWLOCK_UNLOCK();
if (bNeedFree) {
__KHEAP_FREE(piaction);
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_TShellKeywordAddEx
** 功能描述: 向 ttiny shell 系统添加一个关键字.
** 输 入 : pcKeyword 关键字
** pfuncCommand 执行的 shell 函数
** ulOption 选项
** 输 出 : 错误代码.
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_TShellKeywordAddEx (CPCHAR pcKeyword, PCOMMAND_START_ROUTINE pfuncCommand, ULONG ulOption)
{
REGISTER size_t stStrLen;
if (__PROC_GET_PID_CUR() != 0) { /* 进程中不能注册命令 */
_ErrorHandle(ENOTSUP);
return (ENOTSUP);
}
if (!pcKeyword) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "pcKeyword invalidate.\r\n");
_ErrorHandle(ERROR_TSHELL_EPARAM);
return (ERROR_TSHELL_EPARAM);
}
stStrLen = lib_strnlen(pcKeyword, LW_CFG_SHELL_MAX_KEYWORDLEN);
if (stStrLen >= (LW_CFG_SHELL_MAX_KEYWORDLEN + 1)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "pcKeyword is too long.\r\n");
_ErrorHandle(ERROR_TSHELL_EPARAM);
return (ERROR_TSHELL_EPARAM);
}
return (__tshellKeywordAdd(pcKeyword, stStrLen, pfuncCommand, ulOption));
}
/*********************************************************************************************************
** 函数名称: API_BlkRawCreate
** 功能描述: 通过 /dev/blk/xxx 块设备生成一个 BLOCK 控制块 (只能内核程序调用).
** 输 入 : pcBlkName 块设备名称
** bRdOnly 只读
** bLogic 是否为逻辑分区
** pblkraw 创建的 blk raw 控制块
** 输 出 : ERROR_NONE or PX_ERROR
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
LW_API
INT API_BlkRawCreate (CPCHAR pcBlkName, BOOL bRdOnly, BOOL bLogic, PLW_BLK_RAW pblkraw)
{
INT iFlag;
INT iRet;
if (!pcBlkName || !pblkraw) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
iFlag = (bRdOnly) ? O_RDONLY : O_RDWR;
lib_bzero(pblkraw, sizeof(LW_BLK_RAW));
pblkraw->BLKRAW_blkd.BLKD_pcName = lib_strdup(pcBlkName);
if (pblkraw == LW_NULL) {
_ErrorHandle(ENOMEM);
return (PX_ERROR);
}
__KERNEL_SPACE_ENTER();
iRet = __blkRawCreate(pblkraw, iFlag, bLogic);
__KERNEL_SPACE_EXIT();
if (iRet < ERROR_NONE) {
__SHEAP_FREE(pblkraw);
}
return (iRet);
}
/*********************************************************************************************************
** 函数名称: __romFsPRead
** 功能描述: romfs pread 操作
** 输 入 : pfdentry 文件控制块
** pcBuffer 接收缓冲区
** stMaxBytes 接收缓冲区大小
** oftPos 位置
** 输 出 : 驱动相关
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __romFsPRead (PLW_FD_ENTRY pfdentry,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oftPos)
{
PLW_FD_NODE pfdnode = (PLW_FD_NODE)pfdentry->FDENTRY_pfdnode;
PROM_FILE promfile = (PROM_FILE)pfdnode->FDNODE_pvFile;
ssize_t sstRet;
if (!pcBuffer || !stMaxBytes || (oftPos < 0)) {
_ErrorHandle(EINVAL);
return (0);
}
if (promfile->ROMFIL_iFileType != __ROMFS_FILE_TYPE_NODE) {
_ErrorHandle(EISDIR);
return (PX_ERROR);
}
if (__ROMFS_FILE_LOCK(promfile) != ERROR_NONE) {
_ErrorHandle(ENXIO);
return (PX_ERROR);
}
sstRet = __rfs_pread(promfile->ROMFIL_promfs, &promfile->ROMFIL_romfsdnt,
pcBuffer, stMaxBytes, (UINT32)oftPos);
__ROMFS_FILE_UNLOCK(promfile);
return (sstRet);
}
/*********************************************************************************************************
** 函数名称: __romFsSeek
** 功能描述: romFs seek 操作
** 输 入 : pfdentry 文件控制块
** oftOffset 偏移量
** 输 出 : 驱动相关
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __romFsSeek (PLW_FD_ENTRY pfdentry,
off_t oftOffset)
{
PLW_FD_NODE pfdnode = (PLW_FD_NODE)pfdentry->FDENTRY_pfdnode;
PROM_FILE promfile = (PROM_FILE)pfdnode->FDNODE_pvFile;
if (promfile->ROMFIL_iFileType != __ROMFS_FILE_TYPE_NODE) {
return (PX_ERROR);
}
if (oftOffset > promfile->ROMFIL_romfsdnt.ROMFSDNT_stat.st_size) {
_ErrorHandle(EROFS);
return (PX_ERROR);
}
if (__ROMFS_FILE_LOCK(promfile) != ERROR_NONE) {
_ErrorHandle(ENXIO);
return (PX_ERROR);
}
if (promfile->ROMFIL_iFileType != __ROMFS_FILE_TYPE_NODE) {
__ROMFS_FILE_UNLOCK(promfile);
_ErrorHandle(EISDIR);
return (PX_ERROR);
}
pfdentry->FDENTRY_oftPtr = oftOffset;
__ROMFS_FILE_UNLOCK(promfile);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_SetLastErrorEx
** 功能描述: 设置指定任务的 errno
** 输 入 : ulId 任务 ID
** ulError 错误号
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_SetLastErrorEx (LW_OBJECT_HANDLE ulId, ULONG ulError)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcb;
usIndex = _ObjectGetIndex(ulId);
if (!_ObjectClassOK(ulId, _OBJECT_THREAD)) {
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Thread_Index_Invalid(usIndex)) { /* 检查线程有效性 */
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
ptcb = _K_ptcbTCBIdTable[usIndex];
ptcb->TCB_ulLastError = ulError;
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: ls1xWatchDogDevAdd
** 功能描述: 创建 WATCH_DOG 设备
** 输 入 : pcName 设备名
** 输 出 : ERROR_CODE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT ls1xWatchDogDevAdd (CPCHAR cpcName)
{
PLS1X_WDT_DEV pwdt;
pwdt = (PLS1X_WDT_DEV)__SHEAP_ALLOC(sizeof(LS1X_WDT_DEV));
if (!pwdt) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_memset(pwdt, 0, sizeof(LS1X_WDT_DEV));
pwdt->WDT_ulPhyAddrBase = BSP_CFG_WDT_BASE;
pwdt->WDT_time = time(LW_NULL);
if (API_IosDevAddEx(&pwdt->WDT_devhdr, cpcName, _G_ils1xWDTDrvNum, DT_CHR) != ERROR_NONE) {
__SHEAP_FREE(pwdt);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
_ErrorHandle(ERROR_NONE);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: ls1xLedDevCreate
** 功能描述: 创建 LED 设备
** 输 入 : NONE
** pcName 设备名
** uiGpio GPIO Num
** bIsOutPutHigh 初始电平
** 输 出 : 错误号
*********************************************************************************************************/
INT ls1xLedDevCreate (CPCHAR cpcName, UINT uiGpio, BOOL bIsOutPutHigh)
{
PLS1XLED_DEV pled;
pled = (PLS1XLED_DEV)__SHEAP_ALLOC(sizeof(LS1X_LED_DEV));
if (!pled) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_memset(pled, 0, sizeof(LS1X_LED_DEV));
pled->LED_uiGpio = uiGpio;
pled->LED_bIsOutPutHigh = bIsOutPutHigh;
pled->LED_time = time(LW_NULL);
if (API_IosDevAddEx(&pled->LED_devhdr, cpcName, _G_ils1xLedDrvNum, DT_CHR) != ERROR_NONE) {
__SHEAP_FREE(pled);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
_ErrorHandle(ERROR_NONE);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __ram_move
** 功能描述: ramfs 移动或者重命名一个文件
** 输 入 : pramn 文件节点
** pcNewName 新的名字
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT __ram_move (PRAM_NODE pramn, PCHAR pcNewName)
{
PRAM_VOLUME pramfs;
PRAM_NODE pramnTemp;
PRAM_NODE pramnFather;
PRAM_NODE pramnNewFather;
BOOL bRoot;
BOOL bLast;
PCHAR pcTail;
PCHAR pcTemp;
PCHAR pcFileName;
pramfs = pramn->RAMN_pramfs;
pramnFather = pramn->RAMN_pramnFather;
pramnTemp = __ram_open(pramfs, pcNewName, &pramnNewFather, &bRoot, &bLast, &pcTail);
if (pramnTemp) {
_ErrorHandle(EEXIST);
return (PX_ERROR);
}
if (bRoot || (bLast == LW_FALSE)) { /* 新名字指向根或者没有目录 */
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (pramnFather != pramnNewFather) { /* 目录发生改变 */
if (pramnFather) {
_List_Line_Del(&pramn->RAMN_lineBrother,
&pramnFather->RAMN_plineSon);
} else {
_List_Line_Del(&pramn->RAMN_lineBrother,
&pramfs->RAMFS_plineSon);
}
if (pramnNewFather) {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramnNewFather->RAMN_plineSon);
} else {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramfs->RAMFS_plineSon);
}
}
pcFileName = lib_rindex(pcNewName, PX_DIVIDER);
if (pcFileName) {
pcFileName++;
} else {
pcFileName = pcNewName;
}
pcTemp = (PCHAR)__SHEAP_ALLOC(lib_strlen(pcFileName) + 1);
if (pcTemp == LW_NULL) {
_ErrorHandle(ENOMEM);
return (PX_ERROR);
}
lib_strcpy(pcTemp, pcFileName);
__SHEAP_FREE(pramn->RAMN_pcName);
pramn->RAMN_pcName = pcTemp;
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_TShellGetOption
** 功能描述: 获取新的 shell 选项.
** 输 入 : hTShellHandle shell 线程
** pulOpt shell 选项
** 输 出 : 错误代码.
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_TShellGetOption (LW_OBJECT_HANDLE hTShellHandle, ULONG *pulOpt)
{
PLW_CLASS_TCB ptcbShell;
UINT16 usIndex;
if (!pulOpt) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
usIndex = _ObjectGetIndex(hTShellHandle);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(hTShellHandle, _OBJECT_THREAD)) { /* 检查 ID 类型有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (PX_ERROR);
}
#endif
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (PX_ERROR);
}
ptcbShell = __GET_TCB_FROM_INDEX(usIndex);
*pulOpt = __TTINY_SHELL_GET_OPT(ptcbShell);
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_ThreadCancel
** 功能描述: 取消一个指定的线程
** 输 入 : ulId 线程句柄
** 输 出 : ERROR_NONE or ESRCH
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_ThreadCancel (LW_OBJECT_HANDLE *pulId)
{
INTREG iregInterLevel;
REGISTER LW_OBJECT_HANDLE ulId;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcbDel;
ulId = *pulId;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_THREAD)) { /* 检查 ID 类型有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Thread_Index_Invalid(usIndex)) { /* 检查线程有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
#endif
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
iregInterLevel = KN_INT_DISABLE();
ptcbDel = _K_ptcbTCBIdTable[usIndex];
if (ptcbDel->TCB_iCancelState == LW_THREAD_CANCEL_ENABLE) { /* 允许 CANCEL */
if (ptcbDel->TCB_iCancelType == LW_THREAD_CANCEL_DEFERRED) { /* 延迟 CANCEL */
ptcbDel->TCB_bCancelRequest = LW_TRUE; /* 目标线程进入下一个 TEST 点 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核并打开中断 */
} else { /* 异步取消 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核并打开中断 */
#if LW_CFG_SIGNAL_EN > 0
kill(ulId, SIGCANCEL); /* 立即发送取消信号 */
#else
return (API_ThreadDelete(ulId, LW_NULL));
#endif /* LW_CFG_SIGNAL_EN > 0 */
}
} else {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核并打开中断 */
_ErrorHandle(ERROR_THREAD_DISCANCEL); /* 不允许 CACNCEL */
return (ERROR_THREAD_DISCANCEL);
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __procFsYaffsRead
** 功能描述: procfs 读一个 yaffs 文件
** 输 入 : p_pfsn 节点控制块
** pcBuffer 缓冲区
** stMaxBytes 缓冲区大小
** oft 文件指针
** 输 出 : 实际读取的数目
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __procFsYaffsRead (PLW_PROCFS_NODE p_pfsn,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oft)
{
REGISTER PCHAR pcFileBuffer;
size_t stRealSize; /* 实际的文件内容大小 */
size_t stCopeBytes;
/*
* 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小.
*/
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn);
if (pcFileBuffer == LW_NULL) {
_ErrorHandle(ENOMEM);
return (0);
}
stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn);
if (stRealSize == 0) { /* 需要生成文件 */
/*
* 在这里生成文件的内容
*/
INT i = 0;
PCHAR pcVolName;
struct yaffs_dev *pyaffsDev; /* yaffs 挂载设备 */
do {
pcVolName = yaffs_getdevname(i, &i);
if (pcVolName == LW_NULL) {
break; /* 没有其他的卷 */
}
pyaffsDev = (struct yaffs_dev *)yaffs_getdev(pcVolName);
if (pyaffsDev == LW_NULL) {
break; /* 无法查询到设备节点 */
}
/*
* (__PROCFS_BUFFER_SIZE_YAFFS - stRealSize) 为文件缓冲区剩余的空间大小
*/
stRealSize = __procFsYaffsPrint(pyaffsDev,
pcVolName,
pcFileBuffer,
__PROCFS_BUFFER_SIZE_YAFFS,
stRealSize);
} while (i != PX_ERROR);
API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize); /* 回写文件实际大小 */
}
if (oft >= stRealSize) {
_ErrorHandle(ENOSPC);
return (0);
}
stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际拷贝的字节数 */
lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes);
return ((ssize_t)stCopeBytes);
}
/*********************************************************************************************************
** 函数名称: __canWrite
** 功能描述: 写 CAN 设备
** 输 入 :
** pcanDev CAN 设备
** pcanframe 写缓冲区指针
** stNbyte 发送缓冲区字节数
** 输 出 : 返回实际写入的个数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __canWrite (__CAN_DEV *pcanDev,
PCAN_FRAME pcanframe,
size_t stNbyte)
{
INTREG iregInterLevel;
INT iFrameput;
INT i = 0;
ULONG ulError;
__CAN_PORT *pcanport = (__CAN_PORT *)pcanDev;
size_t stNumber = stNbyte / sizeof(CAN_FRAME); /* 转换为数据包个数 */
while (stNumber > 0) {
ulError = API_SemaphoreBPend(pcanDev->CAN_ulSendSemB,
pcanDev->CAN_ulSendTimeout);
if (ulError) {
_ErrorHandle(ERROR_IO_DEVICE_TIMEOUT); /* 超时 */
return ((ssize_t)(i * sizeof(CAN_FRAME)));
}
CANDEV_LOCK(pcanDev); /* 等待设备使用权 */
LW_SPIN_LOCK_QUICK(&pcanDev->CAN_slLock, &iregInterLevel);
if (pcanDev->CAN_uiBusState != CAN_DEV_BUS_ERROR_NONE) { /* 总线错误 */
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
CANDEV_UNLOCK(pcanDev);
_ErrorHandle(EIO);
return ((ssize_t)(i * sizeof(CAN_FRAME)));
}
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
iFrameput = __canWriteQueue(pcanDev,
pcanDev->CAN_pcanqSendQueue,
pcanframe,
(INT)stNumber);
__canTxStartup(pcanport); /* 启动一次发送 */
stNumber -= (size_t)iFrameput; /* 剩余需要发送的数据 */
pcanframe += iFrameput; /* 新的缓冲区起始地址 */
i += iFrameput;
LW_SPIN_LOCK_QUICK(&pcanDev->CAN_slLock, &iregInterLevel);
/* 关闭中断 */
if (__canQFreeNum(pcanDev->CAN_pcanqSendQueue) > 0) {
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel); /* 打开中断 */
API_SemaphoreBPost(pcanDev->CAN_ulSendSemB); /* 缓冲区还有空间 */
} else {
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
/* 打开中断 */
}
CANDEV_UNLOCK(pcanDev); /* 释放设备使用权 */
}
return ((ssize_t)(i * sizeof(CAN_FRAME)));
}
/*********************************************************************************************************
** 函数名称: sigwaitinfo
** 功能描述: 等待 sigset 内信号的到来，以串行的方式从信号队列中取出信号进行处理, 信号将不再被执行.
** 输 入 : psigset 指定的信号集
** psiginfo 获取的信号信息
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT sigwaitinfo (const sigset_t *psigset, struct siginfo *psiginfo)
{
INTREG iregInterLevel;
PLW_CLASS_TCB ptcbCur;
REGISTER PLW_CLASS_PCB ppcb;
INT iSigNo;
PLW_CLASS_SIGCONTEXT psigctx;
struct siginfo siginfo;
LW_CLASS_SIGWAIT sigwt;
if (!psigset) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
__THREAD_CANCEL_POINT(); /* 测试取消点 */
LW_TCB_GET_CUR_SAFE(ptcbCur); /* 当前任务控制块 */
MONITOR_EVT_D2(MONITOR_EVENT_ID_SIGNAL, MONITOR_EVENT_SIGNAL_SIGWAIT,
ptcbCur->TCB_ulId, *psigset, LW_NULL);
__KERNEL_ENTER(); /* 进入内核 */
psigctx = _signalGetCtx(ptcbCur);
iSigNo = _sigPendGet(psigctx, psigset, &siginfo); /* 检查当前是否有等待的信号 */
if (__issig(iSigNo)) {
__KERNEL_EXIT(); /* 退出内核 */
if (psiginfo) {
*psiginfo = siginfo;
}
return (siginfo.si_signo);
}
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
ptcbCur->TCB_usStatus |= LW_THREAD_STATUS_SIGNAL; /* 等待信号 */
ppcb = _GetPcb(ptcbCur);
__DEL_FROM_READY_RING(ptcbCur, ppcb); /* 从就绪表中删除 */
KN_INT_ENABLE(iregInterLevel); /* 打开中断 */
sigwt.SIGWT_sigset = *psigset;
psigctx->SIGCTX_sigwait = &sigwt; /* 保存等待信息 */
if (__KERNEL_EXIT()) { /* 是否其他信号激活 */
psigctx->SIGCTX_sigwait = LW_NULL;
_ErrorHandle(EINTR); /* SA_RESTART 也退出 */
return (PX_ERROR);
}
psigctx->SIGCTX_sigwait = LW_NULL;
if (psiginfo) {
*psiginfo = sigwt.SIGWT_siginfo;
}
return (sigwt.SIGWT_siginfo.si_signo);
}
/*********************************************************************************************************
** 函数名称: __canRead
** 功能描述: 读 CAN 设备
** 输 入 :
** pcanDev CAN 设备
** pcanframe CAN发送缓冲区指针
** stNbyte 读取缓冲区的字节数
** 输 出 : 返回实际读取的个数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __canRead (__CAN_DEV *pcanDev,
PCAN_FRAME pcanframe,
size_t stNbyte)
{
INTREG iregInterLevel;
REGISTER ssize_t sstNRead;
size_t stNumber = stNbyte / sizeof(CAN_FRAME); /* 转换为数据包个数 */
ULONG ulError;
for (;;) {
ulError = API_SemaphoreBPend(pcanDev->CAN_ulRcvSemB,
pcanDev->CAN_ulRecvTimeout);
if (ulError) {
_ErrorHandle(ERROR_IO_DEVICE_TIMEOUT); /* 超时 */
return (0);
}
CANDEV_LOCK(pcanDev); /* 等待设备使用权 */
LW_SPIN_LOCK_QUICK(&pcanDev->CAN_slLock, &iregInterLevel);
/* 关闭中断 */
if (__canQCount(pcanDev->CAN_pcanqRecvQueue)) { /* 检查是否有数据 */
break;
} else {
if (pcanDev->CAN_uiBusState != CAN_DEV_BUS_ERROR_NONE) { /* 总线错误 */
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
CANDEV_UNLOCK(pcanDev);
_ErrorHandle(EIO);
return (0);
}
}
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
/* 打开中断 */
CANDEV_UNLOCK(pcanDev); /* 释放设备使用权 */
}
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
sstNRead = __canReadQueue(pcanDev,
pcanDev->CAN_pcanqRecvQueue,
pcanframe,
(INT)stNumber);
LW_SPIN_LOCK_QUICK(&pcanDev->CAN_slLock, &iregInterLevel);
if (__canQCount(pcanDev->CAN_pcanqRecvQueue)) { /* 是否还有数据 */
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
API_SemaphoreBPost(pcanDev->CAN_ulRcvSemB); /* 通知其他等待读的线程 */
} else {
LW_SPIN_UNLOCK_QUICK(&pcanDev->CAN_slLock, iregInterLevel);
}
CANDEV_UNLOCK(pcanDev); /* 释放设备使用权 */
return (sstNRead * sizeof(CAN_FRAME));
}
/*********************************************************************************************************
** 函数名称: __procFssupRootfsRead
** 功能描述: procfs 读一个根文件系统信息 proc 文件
** 输 入 : p_pfsn 节点控制块
** pcBuffer 缓冲区
** stMaxBytes 缓冲区大小
** oft 文件指针
** 输 出 : 实际读取的数目
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t __procFssupStatRead (PLW_PROCFS_NODE p_pfsn,
PCHAR pcBuffer,
size_t stMaxBytes,
off_t oft)
{
REGISTER PCHAR pcFileBuffer;
size_t stRealSize; /* 实际的文件内容大小 */
size_t stCopeBytes;
/*
* 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小(创建节点时预置大小为 64 字节).
*/
pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn);
if (pcFileBuffer == LW_NULL) {
_ErrorHandle(ENOMEM);
return (0);
}
stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn);
if (stRealSize == 0) { /* 需要生成文件 */
struct statfs statfsBuf;
PCHAR pcFs;
if (p_pfsn->PFSN_p_pfsnoFuncs == &_G_pfsnoFssupRootfsFuncs) {
pcFs = "/";
} else if (p_pfsn->PFSN_p_pfsnoFuncs == &_G_pfsnoFssupProcfsFuncs) {
pcFs = "/proc";
} else {
pcFs = "/"; /* 不可能运行到这里 */
}
if (statfs(pcFs, &statfsBuf) < ERROR_NONE) {
stRealSize = bnprintf(pcFileBuffer,
__PROCFS_BUFFER_SIZE_ROOTFS, 0,
"get root file system status error.");
} else {
stRealSize = bnprintf(pcFileBuffer,
__PROCFS_BUFFER_SIZE_ROOTFS, 0,
"memory used : %ld bytes\n"
"total files : %ld\n",
(ULONG)(statfsBuf.f_bsize * statfsBuf.f_blocks),
statfsBuf.f_files);
}
API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize);
}
if (oft >= stRealSize) {
_ErrorHandle(ENOSPC);
return (0);
}
stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际拷贝的字节数 */
lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes);
return ((ssize_t)stCopeBytes);
}
/*********************************************************************************************************
** 函数名称: _hotplugOpen
** 功能描述: 打开热插拔消息设备
** 输 入 : photplugdev 热插拔消息设备
** pcName 名称
** iFlags 方式
** iMode 方法
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static LONG _hotplugOpen (PLW_HOTPLUG_DEV photplugdev,
PCHAR pcName,
INT iFlags,
INT iMode)
{
PLW_HOTPLUG_FILE photplugfil;
if (pcName == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "device name invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DEVICE_NAME_IN_PATH);
return (PX_ERROR);
} else {
if (iFlags & O_CREAT) {
_ErrorHandle(ERROR_IO_FILE_EXIST); /* 不能重复创建 */
return (PX_ERROR);
}
photplugfil = (PLW_HOTPLUG_FILE)__SHEAP_ALLOC(sizeof(LW_HOTPLUG_FILE));
if (!photplugfil) {
__nomem:
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
photplugfil->HOTPFIL_iFlag = iFlags;
photplugfil->HOTPFIL_iMsg = LW_HOTPLUG_MSG_ALL;
photplugfil->HOTPFIL_pbmsg = _bmsgCreate(LW_CFG_HOTPLUG_DEV_DEFAULT_BUFSIZE);
if (photplugfil->HOTPFIL_pbmsg == LW_NULL) {
__SHEAP_FREE(photplugfil);
goto __nomem;
}
photplugfil->HOTPFIL_ulReadSync = API_SemaphoreBCreate("hotplug_rsync", LW_FALSE,
LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (photplugfil->HOTPFIL_ulReadSync == LW_OBJECT_HANDLE_INVALID) {
_bmsgDelete(photplugfil->HOTPFIL_pbmsg);
__SHEAP_FREE(photplugfil);
return (PX_ERROR);
}
HOTPLUG_DEV_LOCK();
_List_Line_Add_Tail(&photplugfil->HOTPFIL_lineManage,
&_G_hotplugdev.HOTPDEV_plineFile);
HOTPLUG_DEV_UNLOCK();
LW_DEV_INC_USE_COUNT(&_G_hotplugdev.HOTPDEV_devhdrHdr);
return ((LONG)photplugfil);
}
}
LW_API
ULONG API_RegionAddMem (LW_OBJECT_HANDLE ulId, PVOID pvMem, size_t stByteSize)
{
REGISTER PLW_CLASS_HEAP pheap;
REGISTER UINT16 usIndex;
usIndex = _ObjectGetIndex(ulId);
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (ERROR_KERNEL_IN_ISR);
}
#if LW_CFG_ARG_CHK_EN > 0
if (!pvMem || !_Addresses_Is_Aligned(pvMem)) { /* 检查地址是否对齐 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "pvLowAddr is not aligned.\r\n");
_ErrorHandle(ERROR_KERNEL_MEMORY);
return (ERROR_KERNEL_MEMORY);
}
if (_Heap_ByteSize_Invalid(stByteSize)) { /* 分段太小 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "ulRegionByteSize is too low.\r\n");
_ErrorHandle(ERROR_REGION_SIZE);
return (ERROR_REGION_SIZE);
}
if (!_ObjectClassOK(ulId, _OBJECT_REGION)) { /* 对象类型检查 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "region handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
__KERNEL_ENTER(); /* 进入内核 */
if (_Heap_Index_Invalid(usIndex)) { /* 缓冲区索引检查 */
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "region handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#else
__KERNEL_ENTER(); /* 进入内核 */
#endif
pheap = &_K_heapBuffer[usIndex];
__KERNEL_EXIT(); /* 退出内核 */
_HeapAddMemory(pheap, pvMem, stByteSize);
return (ERROR_NONE);
}
LW_API
ULONG API_RmsGetName (LW_OBJECT_HANDLE ulId, PCHAR pcName)
{
REGISTER PLW_CLASS_RMS prms;
REGISTER UINT16 usIndex;
usIndex = _ObjectGetIndex(ulId);
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (ERROR_KERNEL_IN_ISR);
}
#if LW_CFG_ARG_CHK_EN > 0
if (!pcName) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "name invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_PNAME_NULL);
return (ERROR_KERNEL_PNAME_NULL);
}
if (!_ObjectClassOK(ulId, _OBJECT_RMS)) { /* 对象类型检查 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "RMS handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Rms_Index_Invalid(usIndex)) { /* 缓冲区索引检查 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "RMS handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
__KERNEL_ENTER(); /* 进入内核 */
if (_Rms_Type_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "RMS handle invalidate.\r\n");
_ErrorHandle(ERROR_RMS_NULL);
return (ERROR_RMS_NULL);
}
#else
__KERNEL_ENTER(); /* 进入内核 */
#endif
prms = &_K_rmsBuffer[usIndex];
lib_strcpy(pcName, prms->RMS_cRmsName);
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: _hotplugRead
** 功能描述: 读热插拔消息文件
** 输 入 : photplugfil 热插拔消息文件
** pcBuffer 接收缓冲区
** stMaxBytes 接收缓冲区大小
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static ssize_t _hotplugRead (PLW_HOTPLUG_FILE photplugfil,
PCHAR pcBuffer,
size_t stMaxBytes)
{
ULONG ulErrCode;
ULONG ulTimeout;
size_t stMsgLen;
ssize_t sstRet;
if (!pcBuffer || !stMaxBytes) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (photplugfil->HOTPFIL_iFlag & O_NONBLOCK) { /* 非阻塞 IO */
ulTimeout = LW_OPTION_NOT_WAIT;
} else {
ulTimeout = LW_OPTION_WAIT_INFINITE;
}
for (;;) {
ulErrCode = API_SemaphoreBPend(photplugfil->HOTPFIL_ulReadSync, /* 等待数据有效 */
ulTimeout);
if (ulErrCode != ERROR_NONE) { /* 超时 */
_ErrorHandle(EAGAIN);
return (0);
}
HOTPLUG_DEV_LOCK();
stMsgLen = (size_t)_bmsgNBytesNext(photplugfil->HOTPFIL_pbmsg);
if (stMsgLen > stMaxBytes) {
HOTPLUG_DEV_UNLOCK();
API_SemaphoreBPost(photplugfil->HOTPFIL_ulReadSync);
_ErrorHandle(EMSGSIZE); /* 缓冲区太小 */
return (PX_ERROR);
} else if (stMsgLen) {
break; /* 数据可读 */
}
HOTPLUG_DEV_UNLOCK();
}
sstRet = (ssize_t)_bmsgGet(photplugfil->HOTPFIL_pbmsg, pcBuffer, stMaxBytes);
if (!_bmsgIsEmpty(photplugfil->HOTPFIL_pbmsg)) {
API_SemaphoreBPost(photplugfil->HOTPFIL_ulReadSync);
}
HOTPLUG_DEV_UNLOCK();
return (sstRet);
}
/*********************************************************************************************************
** 函数名称: _evtfdOpen
** 功能描述: 打开 eventfd 设备
** 输 入 : pevtfddev eventfd 设备
** pcName 名称
** iFlags 方式
** iMode 方法
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static LONG _evtfdOpen (PLW_EVTFD_DEV pevtfddev,
PCHAR pcName,
INT iFlags,
INT iMode)
{
PLW_EVTFD_FILE pevtfdfil;
if (pcName == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "device name invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DEVICE_NAME_IN_PATH);
return (PX_ERROR);
} else {
if (iFlags & O_CREAT) {
_ErrorHandle(ERROR_IO_FILE_EXIST);
return (PX_ERROR);
}
pevtfdfil = (PLW_EVTFD_FILE)__SHEAP_ALLOC(sizeof(LW_EVTFD_FILE));
if (!pevtfdfil) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
pevtfdfil->EF_iFlag = iFlags;
pevtfdfil->EF_ulReadLock = API_SemaphoreBCreate("evtfd_rlock", LW_FALSE,
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
if (pevtfdfil->EF_ulReadLock == LW_OBJECT_HANDLE_INVALID) {
__SHEAP_FREE(pevtfdfil);
return (PX_ERROR);
}
pevtfdfil->EF_ulWriteLock = API_SemaphoreBCreate("evtfd_wlock", LW_TRUE,
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
if (pevtfdfil->EF_ulWriteLock == LW_OBJECT_HANDLE_INVALID) {
API_SemaphoreBDelete(&pevtfdfil->EF_ulReadLock);
__SHEAP_FREE(pevtfdfil);
return (PX_ERROR);
}
pevtfdfil->EF_u64Counter = 0ull;
lib_bzero(&pevtfdfil->EF_selwulist, sizeof(LW_SEL_WAKEUPLIST));
pevtfdfil->EF_selwulist.SELWUL_hListLock = _G_hEvtfdSelMutex;
LW_SPIN_INIT(&pevtfdfil->EF_slLock);
LW_DEV_INC_USE_COUNT(&_G_evtfddev.ED_devhdrHdr);
return ((LONG)pevtfdfil);
}
}
/*********************************************************************************************************
** 函数名称: __ram_automem
** 功能描述: ramfs 根据需要设置文件缓冲区
** 输 入 : pramn 文件节点
** ulNBlk 需求缓冲数量
** stStart 在此范围内不清零
** stLen
** 输 出 : 增长结果
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __ram_automem (PRAM_NODE pramn, ULONG ulNBlk, size_t stStart, size_t stLen)
{
ULONG i;
ULONG ulNeedAllocBlk;
PRAM_VOLUME pramfs = pramn->RAMN_pramfs;
size_t stCur;
if (ulNBlk <= pramn->RAMN_ulCnt) { /* 实际数目够用 */
return (ERROR_NONE);
} else { /* 需要增加块 */
PRAM_BUFFER pramb;
ulNeedAllocBlk = ulNBlk - pramn->RAMN_ulCnt;
if ((ulNeedAllocBlk + pramfs->RAMFS_ulCurBlk) >
pramfs->RAMFS_ulMaxBlk) { /* 超过文件系统大小限制 */
_ErrorHandle(ENOSPC);
return (PX_ERROR);
}
stCur = (size_t)pramn->RAMN_ulCnt * __RAM_BDATASIZE;
for (i = 0; i < ulNeedAllocBlk; i++) {
pramb = (PRAM_BUFFER)__RAM_BALLOC(__RAM_BSIZE);
if (pramb == LW_NULL) {
_ErrorHandle(ENOSPC);
return (PX_ERROR);
}
if (((stCur < stStart) && ((stCur + __RAM_BDATASIZE) <= stStart)) ||
((stCur > stStart) && (stCur >= (stStart + stLen)))) { /* 判断数据区是否要清零 */
lib_bzero(pramb->RAMB_ucData, __RAM_BDATASIZE);
}
if (pramn->RAMN_plineBEnd) { /* 存在末尾块 */
_List_Line_Add_Right(&pramb->RAMB_lineManage,
pramn->RAMN_plineBEnd);
pramn->RAMN_plineBEnd = &pramb->RAMB_lineManage;
} else { /* 没有缓冲 */
_List_Line_Add_Ahead(&pramb->RAMB_lineManage,
&pramn->RAMN_plineBStart);
pramn->RAMN_plineBEnd = pramn->RAMN_plineBStart;
}
pramfs->RAMFS_ulCurBlk++;
pramn->RAMN_ulCnt++;
}
return (ERROR_NONE);
}
}
LW_API
PVOID API_RegionGet (LW_OBJECT_HANDLE ulId, size_t stByteSize)
{
REGISTER PLW_CLASS_HEAP pheap;
REGISTER UINT16 usIndex;
REGISTER PVOID pvAllocate;
usIndex = _ObjectGetIndex(ulId);
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (LW_NULL);
}
#if LW_CFG_ARG_CHK_EN > 0
if (!stByteSize) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "ulByteSize invalidate\r\n");
_ErrorHandle(ERROR_REGION_SIZE);
return (LW_NULL);
}
if (!_ObjectClassOK(ulId, _OBJECT_REGION)) { /* 对象类型检查 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "region handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (LW_NULL);
}
__KERNEL_ENTER(); /* 进入内核 */
if (_Heap_Index_Invalid(usIndex)) { /* 缓冲区索引检查 */
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "region handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (LW_NULL);
}
#else
__KERNEL_ENTER(); /* 进入内核 */
#endif
pheap = &_K_heapBuffer[usIndex];
__KERNEL_EXIT(); /* 退出内核 */
pvAllocate = _HeapAllocate(pheap, stByteSize, __func__);
if (!pvAllocate) { /* 是否分配成功 */
_ErrorHandle(ERROR_REGION_NULL);
}
return (pvAllocate);
}
/*********************************************************************************************************
** 函数名称: sigsuspend
** 功能描述: 使用指定的掩码等待一个有效信号的到来, 然后返回先前的信号掩码.
** 输 入 : psigsetMask 指定的信号掩码
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT sigsuspend (const sigset_t *psigsetMask)
{
INTREG iregInterLevel;
PLW_CLASS_TCB ptcbCur;
REGISTER PLW_CLASS_PCB ppcb;
BOOL bIsRun;
PLW_CLASS_SIGCONTEXT psigctx;
sigset_t sigsetOld;
if (!psigsetMask) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
__THREAD_CANCEL_POINT(); /* 测试取消点 */
LW_TCB_GET_CUR_SAFE(ptcbCur); /* 当前任务控制块 */
MONITOR_EVT_D2(MONITOR_EVENT_ID_SIGNAL, MONITOR_EVENT_SIGNAL_SIGSUSPEND,
ptcbCur->TCB_ulId, *psigsetMask, LW_NULL);
__KERNEL_ENTER(); /* 进入内核 */
psigctx = _signalGetCtx(ptcbCur);
sigsetOld = psigctx->SIGCTX_sigsetSigBlockMask; /* 记录先前的掩码 */
psigctx->SIGCTX_sigsetSigBlockMask = *psigsetMask & (~__SIGNO_UNMASK);
bIsRun = _sigPendRun(ptcbCur);
if (bIsRun) {
__KERNEL_EXIT(); /* 退出内核 */
sigprocmask(SIG_SETMASK, &sigsetOld, LW_NULL); /* 设置为原先的 mask */
_ErrorHandle(EINTR);
return (PX_ERROR);
}
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
ptcbCur->TCB_usStatus |= LW_THREAD_STATUS_SIGNAL; /* 等待信号 */
ppcb = _GetPcb(ptcbCur);
__DEL_FROM_READY_RING(ptcbCur, ppcb); /* 从就绪表中删除 */
KN_INT_ENABLE(iregInterLevel); /* 打开中断 */
__KERNEL_EXIT(); /* 退出内核 */
sigprocmask(SIG_SETMASK, &sigsetOld, NULL);
_ErrorHandle(EINTR);
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: API_CoroutineDelete
** 功能描述: 删除一个指定的协程.
** 输 入 : pvCrcb 协程句柄
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_CoroutineDelete (PVOID pvCrcb)
{
INTREG iregInterLevel;
REGISTER PLW_CLASS_COROUTINE pcrcbDel = (PLW_CLASS_COROUTINE)pvCrcb;
REGISTER PLW_CLASS_COROUTINE pcrcbNow;
PLW_CLASS_TCB ptcbCur;
if (!LW_SYS_STATUS_IS_RUNNING()) { /* 系统必须已经启动 */
_ErrorHandle(ERROR_KERNEL_NOT_RUNNING);
return (ERROR_KERNEL_NOT_RUNNING);
}
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (ERROR_KERNEL_IN_ISR);
}
if (!pcrcbDel) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "coroutine handle invalidate.\r\n");
_ErrorHandle(EINVAL);
return (EINVAL);
}
LW_TCB_GET_CUR_SAFE(ptcbCur); /* 当前任务控制块 */
pcrcbNow = _LIST_ENTRY(ptcbCur->TCB_pringCoroutineHeader,
LW_CLASS_COROUTINE,
COROUTINE_ringRoutine); /* 获得当前协程 */
if (pcrcbNow == pcrcbDel) { /* 删除当前协程 */
return (API_CoroutineExit());
}
LW_SPIN_LOCK_QUICK(&ptcbCur->TCB_slLock, &iregInterLevel);
_List_Ring_Del(&pcrcbDel->COROUTINE_ringRoutine,
&ptcbCur->TCB_pringCoroutineHeader); /* 从协程表中删除 */
LW_SPIN_UNLOCK_QUICK(&ptcbCur->TCB_slLock, iregInterLevel);
MONITOR_EVT_LONG2(MONITOR_EVENT_ID_COROUTINE, MONITOR_EVENT_COROUTINE_DELETE,
ptcbCur->TCB_ulId, pcrcbDel, LW_NULL);
if (pcrcbDel->COROUTINE_bIsNeedFree) {
_StackFree(ptcbCur,
pcrcbDel->COROUTINE_pstkStackLowAddr, LW_TRUE); /* 释放内存 */
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_PipeDevDelete
** 功能描述: 删除一个管道设备
** 输 入 :
** pcName 管道名称
** bForce 强制删除
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_PipeDevDelete (PCHAR pcName, BOOL bForce)
{
REGISTER PLW_PIPE_DEV p_pipedev;
PCHAR pcTail = LW_NULL;
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)iosDevFind(pcName, &pcTail);
if ((p_pipedev == LW_NULL) || (pcName == pcTail)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "device not found.\r\n");
_ErrorHandle(ERROR_IOS_DEVICE_NOT_FOUND);
return (PX_ERROR);
}
if (bForce == LW_FALSE) {
if (LW_DEV_GET_USE_COUNT(&p_pipedev->PIPEDEV_devhdrHdr)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "too many open files.\r\n");
_ErrorHandle(EBUSY);
return (PX_ERROR);
}
if (SEL_WAKE_UP_LIST_LEN(&p_pipedev->PIPEDEV_selwulList) > 0) {
errno = EBUSY;
return (PX_ERROR);
}
}
iosDevFileAbnormal(&p_pipedev->PIPEDEV_devhdrHdr);
iosDevDelete(&p_pipedev->PIPEDEV_devhdrHdr);
SEL_WAKE_UP_LIST_TERM(&p_pipedev->PIPEDEV_selwulList);
API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
API_MsgQueueDelete(&p_pipedev->PIPEDEV_hMsgQueue);
__SHEAP_FREE((PVOID)p_pipedev);
return (ERROR_NONE);
}