LW_API
ULONG API_TShellSigEvent (LW_OBJECT_HANDLE ulShell, struct sigevent *psigevent, INT iSigCode)
{
REGISTER PLW_CLASS_TCB ptcbShell;
REGISTER PLW_CLASS_TCB ptcbJoin;
LW_OBJECT_HANDLE ulJoin = LW_OBJECT_HANDLE_INVALID;
UINT16 usIndex;
usIndex = _ObjectGetIndex(ulShell);
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_THREAD_NULL);
}
ptcbShell = __GET_TCB_FROM_INDEX(usIndex);
ptcbJoin = ptcbShell->TCB_ptcbJoin;
if (ptcbJoin) { /* 等待其他线程结束 */
ulJoin = ptcbJoin->TCB_ulId;
}
__KERNEL_EXIT(); /* 退出内核 */
if (ulJoin) {
_doSigEvent(ulJoin, psigevent, iSigCode);
} else {
_doSigEvent(ulShell, psigevent, iSigCode);
}
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);
}
/*********************************************************************************************************
** 函数名称: 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_ThreadJoin
** 功能描述: 线程合并
** 输 入 :
** ulId 要合并的目的线程句柄
** ppvRetValAddr 存放线程返回值得地址
** 输 出 : ID
** 全局变量:
** 调用模块:
API 函数
(不得在中断中调用)
*********************************************************************************************************/
LW_API
ULONG API_ThreadJoin (LW_OBJECT_HANDLE ulId, PVOID *ppvRetValAddr)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcbCur;
REGISTER PLW_CLASS_TCB ptcb;
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);
}
LW_TCB_GET_CUR_SAFE(ptcbCur);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_THREAD)) { /* 检查 ID 类型有效性 */
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Thread_Index_Invalid(usIndex)) { /* 检查线程有效性 */
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
#endif
__THREAD_CANCEL_POINT(); /* 测试取消点 */
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
ptcb = _K_ptcbTCBIdTable[usIndex];
if (ptcb == ptcbCur) { /* 不能阻塞自己 */
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread join self.\r\n");
_ErrorHandle(ERROR_THREAD_JOIN_SELF);
return (ERROR_THREAD_JOIN_SELF);
}
if (ptcb->TCB_bDetachFlag) {
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_THREAD_DETACHED);
return (ERROR_THREAD_DETACHED);
}
_ThreadJoin(ptcb, ppvRetValAddr); /* 合并 */
__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);
}
LW_API
PVOID API_RegionGetAlign (LW_OBJECT_HANDLE ulId, size_t stByteSize, size_t stAlign)
{
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);
}
if ((stAlign < sizeof(PVOID)) || (stAlign & (stAlign - 1))) { /* 检查对齐关系 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "iAlign invalidate.\r\n");
_ErrorHandle(ERROR_REGION_ALIGN);
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 = _HeapAllocateAlign(pheap, stByteSize, stAlign, __func__);
if (!pvAllocate) { /* 是否分配成功 */
_ErrorHandle(ERROR_REGION_NOMEM);
}
return (pvAllocate);
}
/*********************************************************************************************************
** 函数名称: _CreateIdleThread
** 功能描述: 内核高层初始化
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
** 注 意 : 最先建立的一定要是 idle 线程, 为每一个 SMP CPU 都建立一个.
*********************************************************************************************************/
static VOID _CreateIdleThread (VOID)
{
#if LW_CFG_SMP_EN > 0
REGISTER INT i;
LW_CLASS_CPUSET cpuset;
#endif
LW_CLASS_THREADATTR threadattr;
API_ThreadAttrBuild(&threadattr,
LW_CFG_THREAD_IDLE_STK_SIZE,
LW_PRIO_IDLE,
(LW_OPTION_THREAD_STK_CHK |
LW_OPTION_THREAD_SAFE |
LW_OPTION_OBJECT_GLOBAL |
LW_OPTION_THREAD_AFFINITY_ALWAYS),
(PVOID)0);
#if LW_CFG_SMP_EN > 0
LW_CPU_ZERO(&cpuset);
for (i = 0; i < LW_NCPUS; i++) {
CHAR cIdle[LW_CFG_OBJECT_NAME_SIZE] = "t_idle";
lib_itoa(i, &cIdle[6], 10);
API_ThreadAttrSetArg(&threadattr, (PVOID)i);
_K_ulIdleId[i] = API_ThreadInit(cIdle, _IdleThread, &threadattr, LW_NULL);
_K_ptcbIdle[i] = _K_ptcbTCBIdTable[_ObjectGetIndex(_K_ulIdleId[i])];
_K_ptcbIdle[i]->TCB_ucSchedPolicy = LW_OPTION_SCHED_FIFO; /* idle 必须是 FIFO 调度器 */
LW_CPU_SET(i, &cpuset); /* 锁定到指定 CPU */
_ThreadSetAffinity(_K_ptcbIdle[i], sizeof(LW_CLASS_CPUSET), &cpuset);
LW_CPU_CLR(i, &cpuset);
API_ThreadStart(_K_ulIdleId[i]);
}
#else
_K_ulIdleId[0] = API_ThreadInit("t_idle", _IdleThread, &threadattr, LW_NULL);
_K_ptcbIdle[0] = _K_ptcbTCBIdTable[_ObjectGetIndex(_K_ulIdleId[0])];
_K_ptcbIdle[0]->TCB_ucSchedPolicy = LW_OPTION_SCHED_FIFO; /* idle 必须是 FIFO 调度器 */
API_ThreadStart(_K_ulIdleId[0]);
#endif /* LW_CFG_SMP_EN > 0 */
}
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);
}
LW_API
ULONG API_SemaphoreCStatus (LW_OBJECT_HANDLE ulId,
ULONG *pulCounter,
ULONG *pulOption,
ULONG *pulThreadBlockNum)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_SEM_C)) { /* 类型是否正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) { /* 下标是否正正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pevent = &_K_eventBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_Event_Type_Invalid(usIndex, LW_TYPE_EVENT_SEMC)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_TYPE);
return (ERROR_EVENT_TYPE);
}
if (pulCounter) {
*pulCounter = pevent->EVENT_ulCounter;
}
if (pulOption) {
*pulOption = pevent->EVENT_ulOption;
}
if (pulThreadBlockNum) {
*pulThreadBlockNum = _EventWaitNum(pevent);
}
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
}
LW_API
ULONG API_MsgQueueClear (LW_OBJECT_HANDLE ulId)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
REGISTER PLW_CLASS_MSGQUEUE pmsgqueue;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_MSGQUEUE)) { /* 类型是否正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) { /* 下标是否正正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pevent = &_K_eventBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_Event_Type_Invalid(usIndex, LW_TYPE_EVENT_MSGQUEUE)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_MSGQUEUE_TYPE);
return (ERROR_MSGQUEUE_TYPE);
}
pmsgqueue = (PLW_CLASS_MSGQUEUE)pevent->EVENT_pvPtr;
pevent->EVENT_ulCounter = 0ul;
pmsgqueue->MSGQUEUE_pucInputPtr = pmsgqueue->MSGQUEUE_pucBufferLowAddr;
pmsgqueue->MSGQUEUE_pucOutputPtr = pmsgqueue->MSGQUEUE_pucBufferLowAddr;
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
MONITOR_EVT_LONG1(MONITOR_EVENT_ID_MSGQ, MONITOR_EVENT_MSGQ_CLEAR, ulId, LW_NULL);
return (ERROR_NONE);
}
LW_API
ULONG API_EventSetStatus (LW_OBJECT_HANDLE ulId,
ULONG *pulEvent,
ULONG *pulOption)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENTSET pes;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_EVENT_SET)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "eventset handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_EventSet_Index_Invalid(usIndex)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "eventset handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pes = &_K_esBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_EventSet_Type_Invalid(usIndex, LW_TYPE_EVENT_EVENTSET)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "eventset handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENTSET_TYPE);
return (ERROR_EVENTSET_TYPE);
}
if (pulEvent) {
*pulEvent = pes->EVENTSET_ulEventSets;
}
if (pulOption) {
*pulOption = 0ul;
}
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_ThreadIsSafe
** 功能描述: 检测目标线程是否处于安全模式.
** 输 入 :
** ulId 线程句柄
** 输 出 :
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
BOOL API_ThreadIsSafe (LW_OBJECT_HANDLE ulId)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcb;
REGISTER BOOL bIsInSafeMode;
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 (LW_FALSE);
}
if (_Thread_Index_Invalid(usIndex)) { /* 检查线程有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (LW_FALSE);
}
#endif
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (LW_FALSE);
}
ptcb = _K_ptcbTCBIdTable[usIndex]; /* 获得 TCB 指针 */
if (ptcb->TCB_ulThreadSafeCounter) {
bIsInSafeMode = LW_TRUE;
} else {
bIsInSafeMode = LW_FALSE;
}
__KERNEL_EXIT(); /* 退出内核 */
return (bIsInSafeMode);
}
/*********************************************************************************************************
** 函数名称: API_ThreadGetSliceEx
** 功能描述: 获得指定线程时间片(扩展接口)
** 输 入 :
** ulId 线程ID
** pusSliceTemp 时间片
** pusCounter 剩余时间片
** 输 出 :
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_ThreadGetSliceEx (LW_OBJECT_HANDLE ulId, UINT16 *pusSliceTemp, UINT16 *pusCounter)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcb;
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);
}
ptcb = _K_ptcbTCBIdTable[usIndex];
if (pusSliceTemp) {
*pusSliceTemp = ptcb->TCB_usSchedSlice;
}
if (pusCounter) {
*pusCounter = ptcb->TCB_usSchedCounter;
}
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
LW_API
ULONG API_ThreadVarDelete (LW_OBJECT_HANDLE ulId, ULONG *pulAddr)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcbCur;
REGISTER PLW_CLASS_TCB ptcb;
REGISTER PLW_LIST_LINE plineVar;
REGISTER PLW_CLASS_THREADVAR pthreadvar;
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);
}
LW_TCB_GET_CUR_SAFE(ptcbCur);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_THREAD)) {
_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);
}
ptcb = _K_ptcbTCBIdTable[usIndex];
for (plineVar = ptcb->TCB_plinePrivateVars; /* 查找 */
plineVar != LW_NULL;
plineVar = _list_line_get_next(plineVar)) {
pthreadvar = _LIST_ENTRY(plineVar, LW_CLASS_THREADVAR, PRIVATEVAR_lineVarList);
if (pthreadvar->PRIVATEVAR_pulAddress == pulAddr) {
if (ptcb == ptcbCur) {
*pulAddr = pthreadvar->PRIVATEVAR_ulValueSave;
}
_List_Line_Del(plineVar, &ptcb->TCB_plinePrivateVars); /* 从 TCB 中解链 */
_Free_ThreadVar_Object(pthreadvar); /* 释放控制块 */
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
}
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "var is not in thread context.\r\n");
_ErrorHandle(ERROR_THREAD_VAR_NOT_EXIST);
return (ERROR_THREAD_VAR_NOT_EXIST);
}
LW_API
ULONG API_RmsStatus (LW_OBJECT_HANDLE ulId,
UINT8 *pucStatus,
ULONG *pulTimeLeft,
LW_OBJECT_HANDLE *pulOwnerId)
{
INTREG iregInterLevel;
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 (!_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);
}
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_Rms_Type_Invalid(usIndex)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "RMS handle invalidate.\r\n");
_ErrorHandle(ERROR_RMS_NULL);
return (ERROR_RMS_NULL);
}
#else
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
#endif
prms = &_K_rmsBuffer[usIndex];
if (pucStatus) {
*pucStatus = prms->RMS_ucStatus;
}
if (prms->RMS_ucStatus == LW_RMS_EXPIRED) { /* 有线程进行周期等待 */
if (pulOwnerId) {
*pulOwnerId = prms->RMS_ptcbOwner->TCB_ulId;
}
if (pulTimeLeft) {
_WakeupStatus(&_K_wuDelay, &prms->RMS_ptcbOwner->TCB_wunDelay, pulTimeLeft);
}
} else { /* 无效状态 */
if (pulOwnerId) {
*pulOwnerId = LW_OBJECT_HANDLE_INVALID;
}
if (pulTimeLeft) {
*pulTimeLeft = 0ul;
}
}
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __resGetHandleBuffer
** 功能描述: 通过句柄获得对应资源记录器的位置
** 输 入 : ulHandle 资源句柄
** 输 出 : 资源节点
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static LW_INLINE PLW_RESOURCE_H __resGetHandleBuffer (LW_OBJECT_HANDLE ulHandle)
{
PLW_RESOURCE_H presh = LW_NULL;
UINT16 usIndex = _ObjectGetIndex(ulHandle);
ULONG ulClass = _ObjectGetClass(ulHandle);
switch (ulClass) {
case _OBJECT_THREAD:
if (usIndex < LW_CFG_MAX_THREADS) {
presh = &_G_reshThreadBuffer[usIndex];
}
break;
case _OBJECT_THREAD_POOL:
if (usIndex < LW_CFG_MAX_THREAD_POOLS) {
presh = &_G_reshThreadPoolBuffer[usIndex];
}
break;
case _OBJECT_SEM_C:
case _OBJECT_SEM_B:
case _OBJECT_SEM_M:
case _OBJECT_MSGQUEUE:
if (usIndex < LW_CFG_MAX_EVENTS) {
presh = &_G_reshEventBuffer[usIndex];
}
break;
case _OBJECT_EVENT_SET:
if (usIndex < LW_CFG_MAX_EVENTSETS) {
presh = &_G_reshEventsetBuffer[usIndex];
}
break;
case _OBJECT_TIMER:
if (usIndex < LW_CFG_MAX_TIMERS) {
presh = &_G_reshTimerBuffer[usIndex];
}
break;
case _OBJECT_PARTITION:
if (usIndex < LW_CFG_MAX_PARTITIONS) {
presh = &_G_reshPartitionBuffer[usIndex];
}
break;
case _OBJECT_REGION:
if (usIndex < LW_CFG_MAX_REGIONS) {
presh = &_G_reshRegionBuffer[usIndex];
}
break;
case _OBJECT_RMS:
if (usIndex < LW_CFG_MAX_RMSS) {
presh = &_G_reshRmsBuffer[usIndex];
}
break;
default:
break;
}
return (presh);
}
/*********************************************************************************************************
** 函数名称: API_TShellCreateEx
** 功能描述: 创建一个 ttiny shell 系统, SylixOS 支持多个终端设备同时运行.
** tshell 可以使用标准 tty 设备, 或者 pty 虚拟终端设备.
** 输 入 : iTtyFd 终端设备的文件描述符
** ulOption 启动参数
** pfuncRunCallback 初始化完毕后, 启动回调
** 输 出 : shell 线程的句柄.
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
LW_OBJECT_HANDLE API_TShellCreateEx (INT iTtyFd, ULONG ulOption, FUNCPTR pfuncRunCallback)
{
LW_CLASS_THREADATTR threadattrTShell;
LW_OBJECT_HANDLE hTShellHandle;
INT iKernelFile;
PLW_CLASS_TCB ptcbShell;
_DebugHandle(__LOGMESSAGE_LEVEL, "ttniy shell system initialize...\r\n");
if (!isatty(iTtyFd)) { /* 检测是否为终端设备 */
_DebugHandle(__ERRORMESSAGE_LEVEL,
"is not a tty or pty device.\r\n");
_DebugHandle(__LOGMESSAGE_LEVEL,
"ttniy shell system is not initialize.\r\n");
return (0);
}
API_TShellInit(); /* 初始化 shell */
if (__PROC_GET_PID_CUR() != 0) { /* 在进程中启动 */
iKernelFile = dup2kernel(iTtyFd); /* 将此文件描述符 dup 到 kernel*/
if (iKernelFile < 0) {
return (0);
}
ulOption |= LW_OPTION_TSHELL_CLOSE_FD; /* 执行完毕后需要关闭文件 */
pfuncRunCallback = LW_NULL; /* 进程创建不得安装回调 */
} else {
iKernelFile = iTtyFd;
}
API_ThreadAttrBuild(&threadattrTShell,
_G_stShellStackSize, /* shell 堆栈大小 */
LW_PRIO_T_SHELL,
LW_CFG_SHELL_THREAD_OPTION | LW_OPTION_OBJECT_GLOBAL,
(PVOID)iKernelFile); /* 构建属性块 */
hTShellHandle = API_ThreadInit("t_tshell", __tshellThread,
&threadattrTShell, LW_NULL); /* 创建 tshell 线程 */
if (!hTShellHandle) {
if (__PROC_GET_PID_CUR() != 0) { /* 在进程中启动 */
__KERNEL_SPACE_ENTER();
close(iKernelFile); /* 内核中关闭 dup 到内核的文件 */
__KERNEL_SPACE_EXIT();
}
_DebugHandle(__ERRORMESSAGE_LEVEL,
"tshell thread can not create.\r\n");
_DebugHandle(__LOGMESSAGE_LEVEL,
"ttniy shell system is not initialize.\r\n");
return (0);
}
ptcbShell = __GET_TCB_FROM_INDEX(_ObjectGetIndex(hTShellHandle));
__TTINY_SHELL_SET_OPT(ptcbShell, ulOption); /* 初始化选项 */
__TTINY_SHELL_SET_CALLBACK(ptcbShell, pfuncRunCallback); /* 初始化启动回调 */
API_ThreadStart(hTShellHandle); /* 启动 shell 线程 */
return (hTShellHandle);
}
/*********************************************************************************************************
** 函数名称: sigqueue
** 功能描述: 发送队列类型信号, 如果是进程, 将发送给其主线程.
** 输 入 : ulId 线程 id 或者 进程号
** iSigNo 信号
** sigvalue 信号 value
** 输 出 : ERROR or OK
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT sigqueue (LW_OBJECT_HANDLE ulId, INT iSigNo, const union sigval sigvalue)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcb;
LW_SEND_VAL sendval;
#if LW_CFG_MODULELOADER_EN > 0
if (ulId < LW_CFG_MAX_THREADS) { /* 进程号 */
ulId = vprocMainThread((pid_t)ulId);
}
#endif /* LW_CFG_MODULELOADER_EN > 0 */
usIndex = _ObjectGetIndex(ulId);
if (!_ObjectClassOK(ulId, _OBJECT_THREAD)) { /* 检查 ID 类型有效性 */
_ErrorHandle(ESRCH);
return (PX_ERROR);
}
if (_Thread_Index_Invalid(usIndex)) { /* 检查线程有效性 */
_ErrorHandle(ESRCH);
return (PX_ERROR);
}
if (!__issig(iSigNo)) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (LW_CPU_GET_CUR_NESTING() || (ulId == API_ThreadIdSelf())) {
_excJobAdd((VOIDFUNCPTR)sigqueue, (PVOID)ulId, (PVOID)iSigNo, (PVOID)sigvalue.sival_ptr,
0, 0, 0);
return (ERROR_NONE);
}
#if LW_CFG_SMP_EN > 0
if (LW_NCPUS > 1) { /* 正工作在 SMP 多核模式 */
if (API_ThreadStop(ulId)) {
return (PX_ERROR);
}
}
#endif /* LW_CFG_SMP_EN */
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ESRCH);
return (PX_ERROR);
}
ptcb = __GET_TCB_FROM_INDEX(usIndex);
if (ptcb->TCB_iDeleteProcStatus) {
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_THREAD_OTHER_DELETE);
return (PX_ERROR);
}
sendval = _doSigQueue(ptcb, iSigNo, sigvalue);
#if LW_CFG_SMP_EN > 0
if (LW_NCPUS > 1) { /* 正工作在 SMP 多核模式 */
_ThreadContinue(ptcb, LW_FALSE); /* 在内核状态下唤醒被停止线程 */
}
#endif /* LW_CFG_SMP_EN */
__KERNEL_EXIT(); /* 退出内核 */
#if LW_CFG_SIGNALFD_EN > 0
if (sendval == SEND_BLOCK) {
_sigfdReadUnblock(ulId, iSigNo);
}
#endif /* LW_CFG_SIGNALFD_EN > 0 */
return (ERROR_NONE);
}
LW_API
ULONG API_SemaphoreMPost (LW_OBJECT_HANDLE ulId)
{
INTREG iregInterLevel;
PLW_CLASS_TCB ptcbCur;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
REGISTER PLW_CLASS_TCB ptcb;
REGISTER PLW_LIST_RING *ppringList; /* 等待队列地址 */
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);
}
LW_TCB_GET_CUR_SAFE(ptcbCur); /* 当前任务控制块 */
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_SEM_M)) { /* 类型是否正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) { /* 下标是否正正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pevent = &_K_eventBuffer[usIndex];
if (!LW_SYS_STATUS_IS_RUNNING()) { /* 系统还没有启动 */
return (ERROR_NONE);
}
__KERNEL_ENTER(); /* 进入内核 */
if (_Event_Type_Invalid(usIndex, LW_TYPE_EVENT_MUTEX)) {
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_TYPE);
return (ERROR_EVENT_TYPE);
}
if (ptcbCur != (PLW_CLASS_TCB)pevent->EVENT_pvTcbOwn) { /* 是否是拥有者 */
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_EVENT_NOT_OWN); /* 没有事件所有权 */
return (ERROR_EVENT_NOT_OWN);
}
if (pevent->EVENT_pvPtr) { /* 检测是否进行了连续调用 */
pevent->EVENT_pvPtr = (PVOID)((ULONG)pevent->EVENT_pvPtr - 1); /* 临时计数器-- */
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
iregInterLevel = KN_INT_DISABLE();
if (_EventWaitNum(pevent)) {
if (pevent->EVENT_ulOption & LW_OPTION_WAIT_PRIORITY) { /* 优先级等待队列 */
_EVENT_DEL_Q_PRIORITY(ppringList); /* 检查需要激活的队列 */
/* 激活优先级等待线程 */
ptcb = _EventReadyPriorityLowLevel(pevent, LW_NULL, ppringList);
} else {
_EVENT_DEL_Q_FIFO(ppringList); /* 检查需要激活的FIFO队列 */
/* 激活FIFO等待线程 */
ptcb = _EventReadyFifoLowLevel(pevent, LW_NULL, ppringList);
}
KN_INT_ENABLE(iregInterLevel);
_EventPrioTryResume(pevent, ptcbCur); /* 尝试返回之前的优先级 */
pevent->EVENT_ulMaxCounter = (ULONG)ptcb->TCB_ucPriority;
pevent->EVENT_pvTcbOwn = (PVOID)ptcb; /* 保存线程信息 */
_EventReadyHighLevel(ptcb, LW_THREAD_STATUS_SEM); /* 处理 TCB */
MONITOR_EVT_LONG2(MONITOR_EVENT_ID_SEMM, MONITOR_EVENT_SEM_POST,
ulId, ptcb->TCB_ulId, LW_NULL);
__KERNEL_EXIT(); /* 退出内核 */
if (pevent->EVENT_ulOption & LW_OPTION_DELETE_SAFE) { /* 退出安全模式 */
_ThreadUnsafeInternal();
}
return (ERROR_NONE);
} else { /* 没有线程等待 */
KN_INT_ENABLE(iregInterLevel);
if (pevent->EVENT_ulCounter == LW_FALSE) { /* 检查是否还有空间加 */
pevent->EVENT_ulCounter = (ULONG)LW_TRUE;
pevent->EVENT_ulMaxCounter = LW_PRIO_LOWEST; /* 清空保存信息 */
pevent->EVENT_pvTcbOwn = LW_NULL;
__KERNEL_EXIT(); /* 退出内核 */
if (pevent->EVENT_ulOption & LW_OPTION_DELETE_SAFE) { /* 退出安全模式 */
_ThreadUnsafeInternal();
}
return (ERROR_NONE);
} else { /* 已经满了 */
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_EVENT_FULL);
return (ERROR_EVENT_FULL);
}
}
}
LW_API
ULONG API_SemaphoreCPost (LW_OBJECT_HANDLE ulId)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
REGISTER PLW_CLASS_TCB ptcb;
REGISTER PLW_LIST_RING *ppringList; /* 等待队列地址 */
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_SEM_C)) { /* 类型是否正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) { /* 下标是否正正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pevent = &_K_eventBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_Event_Type_Invalid(usIndex, LW_TYPE_EVENT_SEMC)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_TYPE);
return (ERROR_EVENT_TYPE);
}
if (_EventWaitNum(pevent)) {
if (pevent->EVENT_ulOption & LW_OPTION_WAIT_PRIORITY) { /* 优先级等待队列 */
_EVENT_DEL_Q_PRIORITY(ppringList); /* 检查需要激活的队列 */
/* 激活优先级等待线程 */
ptcb = _EventReadyPriorityLowLevel(pevent, LW_NULL, ppringList);
} else {
_EVENT_DEL_Q_FIFO(ppringList); /* 检查需要激活的FIFO队列 */
/* 激活FIFO等待线程 */
ptcb = _EventReadyFifoLowLevel(pevent, LW_NULL, ppringList);
}
KN_INT_ENABLE(iregInterLevel); /* 使能中断 */
_EventReadyHighLevel(ptcb, LW_THREAD_STATUS_SEM); /* 处理 TCB */
MONITOR_EVT_LONG2(MONITOR_EVENT_ID_SEMC, MONITOR_EVENT_SEM_POST,
ulId, ptcb->TCB_ulId, LW_NULL);
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
} else { /* 没有线程等待 */
if (pevent->EVENT_ulCounter < pevent->EVENT_ulMaxCounter) { /* 检查是否还有空间加 */
pevent->EVENT_ulCounter++;
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
} else { /* 已经满了 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_ErrorHandle(ERROR_EVENT_FULL);
return (ERROR_EVENT_FULL);
}
}
}
LW_API
ULONG API_MsgQueueReceive (LW_OBJECT_HANDLE ulId,
PVOID pvMsgBuffer,
size_t stMaxByteSize,
size_t *pstMsgLen,
ULONG ulTimeout)
{
INTREG iregInterLevel;
PLW_CLASS_TCB ptcbCur;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
REGISTER PLW_CLASS_MSGQUEUE pmsgqueue;
REGISTER UINT8 ucPriorityIndex;
REGISTER PLW_LIST_RING *ppringList;
ULONG ulTimeSave; /* 系统事件记录 */
INT iSchedRet;
ULONG ulEventOption; /* 事件创建选项 */
size_t stMsgLenTemp; /* 临时记录变量 */
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);
}
LW_TCB_GET_CUR_SAFE(ptcbCur); /* 当前任务控制块 */
if (pstMsgLen == LW_NULL) {
pstMsgLen = &stMsgLenTemp; /* 临时变量记录消息长短 */
}
__wait_again:
#if LW_CFG_ARG_CHK_EN > 0
if (!pvMsgBuffer || !stMaxByteSize) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "pvMsgBuffer invalidate.\r\n");
_ErrorHandle(ERROR_MSGQUEUE_MSG_NULL);
return (ERROR_MSGQUEUE_MSG_NULL);
}
if (!_ObjectClassOK(ulId, _OBJECT_MSGQUEUE)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pevent = &_K_eventBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_Event_Type_Invalid(usIndex, LW_TYPE_EVENT_MSGQUEUE)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_MSGQUEUE_TYPE);
return (ERROR_MSGQUEUE_TYPE);
}
pmsgqueue = (PLW_CLASS_MSGQUEUE)pevent->EVENT_pvPtr;
ptcbCur->TCB_ulRecvOption = LW_OPTION_NOERROR; /* 接收大消息自动截断 */
if (pevent->EVENT_ulCounter) { /* 事件有效 */
pevent->EVENT_ulCounter--;
_MsgQueueGetMsg(pmsgqueue,
pvMsgBuffer,
stMaxByteSize,
pstMsgLen); /* 获得消息 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
}
if (ulTimeout == LW_OPTION_NOT_WAIT) { /* 不等待 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_ErrorHandle(ERROR_THREAD_WAIT_TIMEOUT); /* 超时 */
return (ERROR_THREAD_WAIT_TIMEOUT);
}
ptcbCur->TCB_pstMsgByteSize = pstMsgLen;
ptcbCur->TCB_stMaxByteSize = stMaxByteSize;
ptcbCur->TCB_pvMsgQueueMessage = pvMsgBuffer; /* 记录信息 */
ptcbCur->TCB_usStatus |= LW_THREAD_STATUS_MSGQUEUE; /* 写状态位，开始等待 */
ptcbCur->TCB_ucWaitTimeout = LW_WAIT_TIME_CLEAR; /* 清空等待时间 */
if (ulTimeout == LW_OPTION_WAIT_INFINITE) { /* 是否是无穷等待 */
ptcbCur->TCB_ulDelay = 0ul;
} else {
ptcbCur->TCB_ulDelay = ulTimeout; /* 设置超时时间 */
}
__KERNEL_TIME_GET_NO_SPINLOCK(ulTimeSave, ULONG); /* 记录系统时间 */
if (pevent->EVENT_ulOption & LW_OPTION_WAIT_PRIORITY) {
_EVENT_INDEX_Q_PRIORITY(ptcbCur->TCB_ucPriority, ucPriorityIndex);
_EVENT_PRIORITY_Q_PTR(ppringList, ucPriorityIndex);
ptcbCur->TCB_ppringPriorityQueue = ppringList; /* 记录等待队列位置 */
_EventWaitPriority(pevent, ppringList); /* 加入优先级等待表 */
} else { /* 按 FIFO 等待 */
_EVENT_FIFO_Q_PTR(ppringList); /* 确定 FIFO 队列的位置 */
_EventWaitFifo(pevent, ppringList); /* 加入 FIFO 等待表 */
}
KN_INT_ENABLE(iregInterLevel); /* 使能中断 */
ulEventOption = pevent->EVENT_ulOption;
MONITOR_EVT_LONG2(MONITOR_EVENT_ID_MSGQ, MONITOR_EVENT_MSGQ_PEND,
ulId, ulTimeout, LW_NULL);
iSchedRet = __KERNEL_EXIT(); /* 调度器解锁 */
if (iSchedRet == LW_SIGNAL_EINTR) {
if (ulEventOption & LW_OPTION_SIGNAL_INTER) {
_ErrorHandle(EINTR);
return (EINTR);
}
ulTimeout = _sigTimeoutRecalc(ulTimeSave, ulTimeout); /* 重新计算超时时间 */
goto __wait_again;
} else if (iSchedRet == LW_SIGNAL_RESTART) {
ulTimeout = _sigTimeoutRecalc(ulTimeSave, ulTimeout); /* 重新计算超时时间 */
goto __wait_again;
}
if (ptcbCur->TCB_ucWaitTimeout == LW_WAIT_TIME_OUT) {
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (ptcbCur->TCB_ucWaitTimeout == LW_WAIT_TIME_CLEAR) { /* 是否在上面瞬间被激活 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
}
if (pevent->EVENT_ulOption & LW_OPTION_WAIT_PRIORITY) {
_EventTimeoutPriority(pevent, ppringList); /* 等待超时恢复 */
} else {
_EventTimeoutFifo(pevent, ppringList); /* 等待超时恢复 */
}
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_ErrorHandle(ERROR_THREAD_WAIT_TIMEOUT); /* 超时 */
return (ERROR_THREAD_WAIT_TIMEOUT);
} else {
if (ptcbCur->TCB_ucIsEventDelete == LW_EVENT_EXIST) { /* 事件是否存在 */
return (ERROR_NONE);
} else {
_ErrorHandle(ERROR_MSGQUEUE_WAS_DELETED); /* 已经被删除 */
return (ERROR_MSGQUEUE_WAS_DELETED);
}
}
}
LW_API
ULONG API_SemaphoreBDelete (LW_OBJECT_HANDLE *pulId)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
REGISTER PLW_CLASS_TCB ptcb;
REGISTER PLW_LIST_RING *ppringList; /* 等待队列地址 */
REGISTER LW_OBJECT_HANDLE ulId;
ulId = *pulId;
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 (!_ObjectClassOK(ulId, _OBJECT_SEM_B)) { /* 类型是否正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) { /* 下标是否正正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pevent = &_K_eventBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_Event_Type_Invalid(usIndex, LW_TYPE_EVENT_SEMB)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_TYPE);
return (ERROR_EVENT_TYPE);
}
_ObjectCloseId(pulId); /* 清除句柄 */
pevent->EVENT_ucType = LW_TYPE_EVENT_UNUSED; /* 事件类型为空 */
while (_EventWaitNum(pevent)) { /* 是否存在正在等待的任务 */
if (pevent->EVENT_ulOption & LW_OPTION_WAIT_PRIORITY) { /* 优先级等待队列 */
_EVENT_DEL_Q_PRIORITY(ppringList); /* 检查需要激活的队列 */
/* 激活优先级等待线程 */
ptcb = _EventReadyPriorityLowLevel(pevent, LW_NULL, ppringList);
} else {
_EVENT_DEL_Q_FIFO(ppringList); /* 查找 FIFO 队列指针地址 */
/* 激活FIFO等待线程 */
ptcb = _EventReadyFifoLowLevel(pevent, LW_NULL, ppringList);
}
KN_INT_ENABLE(iregInterLevel); /* 打开中断 */
ptcb->TCB_ucIsEventDelete = LW_EVENT_DELETE; /* 事件已经被删除 */
_EventReadyHighLevel(ptcb, LW_THREAD_STATUS_SEM); /* 处理 TCB */
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
}
pevent->EVENT_pvTcbOwn = LW_NULL;
_Free_Event_Object(pevent); /* 交还控制块 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
__LW_OBJECT_DELETE_HOOK(ulId);
MONITOR_EVT_LONG1(MONITOR_EVENT_ID_SEMB, MONITOR_EVENT_SEM_DELETE, ulId, LW_NULL);
_DebugFormat(__LOGMESSAGE_LEVEL, "semaphore \"%s\" has been delete.\r\n", pevent->EVENT_cEventName);
return (ERROR_NONE);
}
ULONG __threadDelete (PLW_CLASS_TCB ptcbDel, BOOL bIsInSafe,
PVOID pvRetVal, BOOL bIsAlreadyWaitDeath)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_PCB ppcbDel;
REGISTER LW_OBJECT_HANDLE ulId;
REGISTER PVOID pvFreeLowAddr; /* 要释放的内存地址 */
PVOID pvVProc;
#if (LW_CFG_EVENTSET_EN > 0) && (LW_CFG_MAX_EVENTSETS > 0)
REGISTER PLW_EVENTSETNODE pesnPtr;
#endif
ulId = ptcbDel->TCB_ulId;
usIndex = _ObjectGetIndex(ulId);
if (bIsAlreadyWaitDeath == LW_FALSE) {
_ThreadDeleteWaitDeath(ptcbDel); /* 将要删除的线程进入僵死状态 */
}
__KERNEL_ENTER(); /* 进入内核 */
ppcbDel = _GetPcb(ptcbDel);
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
if (ptcbDel->TCB_ptcbDeleteWait) { /* 目标线程正在等待其他任务删除*/
ptcbDel->TCB_ptcbDeleteWait->TCB_ptcbDeleteMe = (PLW_CLASS_TCB)1;
ptcbDel->TCB_ptcbDeleteWait = LW_NULL;
}
#if (LW_CFG_EVENT_EN > 0) && (LW_CFG_MAX_EVENTS > 0)
if (ptcbDel->TCB_peventPtr) { /* 等待事件中 */
_EventUnlink(ptcbDel); /* 解等待连 */
}
#endif
#if (LW_CFG_EVENTSET_EN > 0) && (LW_CFG_MAX_EVENTSETS > 0)
pesnPtr = ptcbDel->TCB_pesnPtr;
if (pesnPtr) {
_EventSetUnlink(pesnPtr); /* 解事件集 */
}
#endif
#if LW_CFG_SMP_EN > 0
if (ptcbDel->TCB_ptcbWaitStatus ||
ptcbDel->TCB_plineStatusReqHeader) { /* 正在请求其他线程改变状态 */
_ThreadUnwaitStatus(ptcbDel);
}
#endif /* LW_CFG_SMP_EN */
if (__LW_THREAD_IS_READY(ptcbDel)) { /* 是否就绪 */
__DEL_FROM_READY_RING(ptcbDel, ppcbDel); /* 从就绪队列中删除 */
} else {
if (ptcbDel->TCB_usStatus & LW_THREAD_STATUS_DELAY) {
__DEL_FROM_WAKEUP_LINE(ptcbDel); /* 从等待链中删除 */
ptcbDel->TCB_ulDelay = 0ul;
}
ptcbDel->TCB_usStatus = LW_THREAD_STATUS_RDY; /* 防止 Tick 中断激活 */
}
#if LW_CFG_SOFTWARE_WATCHDOG_EN > 0
if (ptcbDel->TCB_bWatchDogInQ) {
__DEL_FROM_WATCHDOG_LINE(ptcbDel); /* 从 watch dog 中删除 */
ptcbDel->TCB_ulWatchDog = 0ul;
}
#endif
KN_INT_ENABLE(iregInterLevel);
pvFreeLowAddr = (PVOID)ptcbDel->TCB_pstkStackLowAddr; /* 记录地址 */
#if (LW_CFG_THREAD_PRIVATE_VARS_EN > 0) && (LW_CFG_MAX_THREAD_GLB_VARS > 0)
_ThreadVarDelete(ptcbDel); /* 删除并恢复私有化的全局变量 */
#endif
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
_K_usThreadCounter--;
_K_ptcbTCBIdTable[usIndex] = LW_NULL; /* TCB 表清0 */
_List_Line_Del(&ptcbDel->TCB_lineManage, &_K_plineTCBHeader); /* 从管理练表中删除 */
KN_INT_ENABLE(iregInterLevel); /* 打开中断 */
if (ptcbDel->TCB_ptcbJoin) {
_ThreadDisjoin(ptcbDel->TCB_ptcbJoin, ptcbDel); /* 退出 join 状态, 不操作就绪表*/
}
_ThreadDisjoinWakeupAll(ptcbDel, pvRetVal); /* DETACH */
__KERNEL_EXIT(); /* 退出内核 */
#if LW_CFG_COROUTINE_EN > 0
_CoroutineFreeAll(ptcbDel); /* 删除协程内存空间 */
#endif /* LW_CFG_COROUTINE_EN > 0 */
if (bIsInSafe) {
_DebugFormat(__ERRORMESSAGE_LEVEL,
"thread \"%s\" has been delete in SAFE mode.\r\n",
ptcbDel->TCB_cThreadName);
} else {
_DebugFormat(__LOGMESSAGE_LEVEL,
"thread \"%s\" has been delete.\r\n",
ptcbDel->TCB_cThreadName);
}
pvVProc = ptcbDel->TCB_pvVProcessContext; /* 进程信息 */
if (ptcbDel->TCB_ucStackAutoAllocFlag) { /* 是否是内核堆开辟堆栈 */
#if LW_CFG_MODULELOADER_EN > 0
vprocStackFree(ptcbDel, pvFreeLowAddr, LW_FALSE);
#else
__KHEAP_FREE(pvFreeLowAddr); /* 释放堆栈空间 */
#endif /* LW_CFG_MODULELOADER_EN > 0 */
}
_TCBDestroy(ptcbDel); /* 销毁 TCB */
__KERNEL_MODE_PROC(
_Free_Tcb_Object(ptcbDel); /* 释放 ID */
);
