/********************************************************************************************************* ** 函数名称: __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); }
/********************************************************************************************************* ** 函数名称: _ThreadUnwaitStatus ** 功能描述: 从等待目标线程状态设置链表中退出, 并激活其他任务等待我的状态改变.(进入内核并关中断状态被调用) ** 输 入 : ptcbCur 当前线程控制块 ** ptcbDest 目标线程控制块 ** uiStatusReq 请求改变的 ** 输 出 : ERROR ** 全局变量: ** 调用模块: ** 注 意 : 这里只是退出链表, 并不操作就续表. *********************************************************************************************************/ VOID _ThreadUnwaitStatus (PLW_CLASS_TCB ptcb) { PLW_CLASS_TCB ptcbDest = ptcb->TCB_ptcbWaitStatus; PLW_CLASS_TCB ptcbWait; PLW_CLASS_PCB ppcb; if (ptcbDest) { _List_Line_Del(&ptcb->TCB_lineStatusPend, &ptcbDest->TCB_plineStatusReqHeader); ptcb->TCB_ptcbWaitStatus = LW_NULL; ptcb->TCB_uiStatusChangeReq = 0; } while (ptcb->TCB_plineStatusReqHeader) { /* 有其他线程请求 */ ptcbWait = _LIST_ENTRY(ptcb->TCB_plineStatusReqHeader, LW_CLASS_TCB, TCB_lineStatusPend); ptcbWait->TCB_ptcbWaitStatus = LW_NULL; _List_Line_Del(&ptcbWait->TCB_lineStatusPend, &ptcb->TCB_plineStatusReqHeader); if (!__LW_THREAD_IS_READY(ptcbWait)) { /* 如果没有就绪, 取消 WSTAT */ ptcbWait->TCB_usStatus &= ~LW_THREAD_STATUS_WSTAT; if (__LW_THREAD_IS_READY(ptcbWait)) { ptcbWait->TCB_ucSchedActivate = LW_SCHED_ACT_INTERRUPT; /* 中断激活方式 */ ppcb = _GetPcb(ptcbWait); __ADD_TO_READY_RING(ptcbWait, ppcb); } } } }
/********************************************************************************************************* ** 函数名称: __aioRemoveAiocb ** 功能描述: 将指定的 aiocb 从 aio req chain 节点下属的队列中移除 (这里必须锁定 _G_aioqueue 与 paiorc) ** 输 入 : paiorc aio req chain 节点 ** paiocb 指定的 aiocb ** iError 保存的返回值 ** iErrNo 保存的错误号 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ INT __aioRemoveAiocb (AIO_REQ_CHAIN *paiorc, struct aiocb *paiocb, INT iError, INT iErrNo) { PLW_LIST_LINE plineTemp; struct aioreq *paioreqTemp; struct aiocb *paiocbTemp; for (plineTemp = paiorc->aiorc_plineaiocb; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { paioreqTemp = _LIST_ENTRY(plineTemp, struct aioreq, aioreq_line); paiocbTemp = _LIST_ENTRY(paioreqTemp, struct aiocb, aio_req); if (paiocbTemp == paiocb) { _List_Line_Del(plineTemp, &paiorc->aiorc_plineaiocb); paioreqTemp->aioreq_error = iErrNo; paioreqTemp->aioreq_return = iError; if (paiocbTemp->aio_pwait) { __aioDetachWait(paiocbTemp, LW_NULL); /* detach wait 关联 */ } return (AIO_CANCELED); } } return (AIO_NOTCANCELED); }
/********************************************************************************************************* ** 函数名称: __rtDelCallback ** 功能描述: 删除一个 sylixos 路由条目(从链表中移除, 在 TCPIP 上下文中执行) ** 输 入 : pipaddrDest 目标地址 ** 输 出 : ERROR ** 全局变量: ** 调用模块: *********************************************************************************************************/ static INT __rtDelCallback (ip_addr_t *pipaddrDest) { PLW_RT_ENTRY prte; prte = __rtFind(pipaddrDest, 0); if (prte) { INT iHash = LW_RT_HASHINDEX(&prte->RTE_ipaddrDest); if (prte->RTE_uiFlag & LW_RT_FLAG_U) { _G_uiActiveNum--; } _G_uiTotalNum--; LW_RT_CACHE_INVAL(prte); _List_Line_Del(&prte->RTE_lineManage, &_G_plineRtHashHeader[iHash]); __SHEAP_FREE(prte); return (ERROR_NONE); } _ErrorHandle(EINVAL); return (PX_ERROR); }
/********************************************************************************************************* ** 函数名称: pthread_key_delete ** 功能描述: 删除一个数据键. (注意, 删除函数不会调用创建时安装的析构函数) ** 输 入 : key 键 ** 输 出 : ERROR CODE ** 全局变量: ** 调用模块: API 函数 *********************************************************************************************************/ LW_API int pthread_key_delete (pthread_key_t key) { __PX_KEY_NODE *pkeyn = (__PX_KEY_NODE *)key; if (key == 0) { errno = EINVAL; return (EINVAL); } __pthreadDataDeleteByKey(key); /* 删除所有与此 key 相关的数据 */ __PX_LOCK(); /* 锁住 posix 库 */ _List_Line_Del(&pkeyn->PKEYN_lineManage, &_G_plineKeyHeader); /* 从 key 键链表中删除 */ __PX_UNLOCK(); /* 解锁 posix 库 */ API_SemaphoreMDelete(&pkeyn->PKEYN_ulMutex); __resDelRawHook(&pkeyn->PKEYN_resraw); __SHEAP_FREE(pkeyn); /* 释放 key */ return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: __pthreadDataDeleteByKey ** 功能描述: 删除指定 key 键的所有数据节点. ** 输 入 : lId 键id ** 输 出 : ERROR CODE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static INT __pthreadDataDeleteByKey (long lId) { __PX_KEY_NODE *pkeyn = (__PX_KEY_NODE *)lId; __PX_KEY_DATA *pkeyd; if (pkeyn == LW_NULL) { /* 没有 key 键 */ errno = EINVAL; return (EINVAL); } /* * key 键删除, 需要遍历 key 键的私有数据表, 删除所有私有数据 */ __PX_KEY_LOCK(pkeyn); /* 锁住 key 键 */ while (pkeyn->PKEYN_plineKeyHeader) { pkeyd = (__PX_KEY_DATA *)pkeyn->PKEYN_plineKeyHeader; /* 链表是 KEY DATA 的第一个元素*/ _List_Line_Del(&pkeyd->PKEYD_lineManage, &pkeyn->PKEYN_plineKeyHeader); /* 从链表中删除 */ __SHEAP_FREE(pkeyd); /* 释放线程私有数据内存 */ } __PX_KEY_UNLOCK(pkeyn); /* 解锁 key 键 */ return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: 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_HotplugPollDelete ** 功能描述: 从 hotplug 事件处理上下文中, 删除一个循环检测函数. ** 输 入 : pfunc 函数指针 ** pvArg 函数参数 ** 输 出 : 操作是否成功 ** 全局变量: ** 调用模块: API 函数 *********************************************************************************************************/ LW_API INT API_HotplugPollDelete (VOIDFUNCPTR pfunc, PVOID pvArg) { PLW_HOTPLUG_POLLNODE phppn = LW_NULL; PLW_LIST_LINE plineTemp; __HOTPLUG_LOCK(); /* lock hotplug poll list */ for (plineTemp = _G_plineHotplugPoll; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { phppn = _LIST_ENTRY(plineTemp, LW_HOTPLUG_POLLNODE, HPPN_lineManage); if ((phppn->HPPN_pfunc == pfunc) && (phppn->HPPN_pvArg == pvArg)) { _List_Line_Del(&phppn->HPPN_lineManage, &_G_plineHotplugPoll); break; } } __HOTPLUG_UNLOCK(); /* unlock hotplug poll list */ if (plineTemp != LW_NULL) { __resDelRawHook(&phppn->HPPN_resraw); __SHEAP_FREE(phppn); return (ERROR_NONE); } _ErrorHandle(ERROR_HOTPLUG_POLL_NODE_NULL); return (PX_ERROR); }
/********************************************************************************************************* ** 函数名称: __ram_unlink ** 功能描述: ramfs 删除一个文件 ** 输 入 : pramn 文件节点 ** 输 出 : 删除结果 ** 全局变量: ** 调用模块: *********************************************************************************************************/ INT __ram_unlink (PRAM_NODE pramn) { PRAM_VOLUME pramfs; PRAM_NODE pramnFather; PLW_LIST_LINE plineTemp; if (S_ISDIR(pramn->RAMN_mode) && pramn->RAMN_plineSon) { _ErrorHandle(ENOTEMPTY); return (PX_ERROR); } pramfs = pramn->RAMN_pramfs; pramnFather = pramn->RAMN_pramnFather; if (pramnFather) { _List_Line_Del(&pramn->RAMN_lineBrother, &pramnFather->RAMN_plineSon); } else { _List_Line_Del(&pramn->RAMN_lineBrother, &pramfs->RAMFS_plineSon); } while (pramn->RAMN_plineBStart) { plineTemp = pramn->RAMN_plineBStart; _List_Line_Del(plineTemp, &pramn->RAMN_plineBStart); __RAM_BFREE(plineTemp); pramfs->RAMFS_ulCurBlk--; pramn->RAMN_ulCnt--; } if (S_ISLNK(pramn->RAMN_mode)) { __SHEAP_FREE(pramn->RAMN_pcLink); } __SHEAP_FREE(pramn->RAMN_pcName); __SHEAP_FREE(pramn); return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: __aioDeleteFd ** 功能描述: 从指定的 AIO_REQ_CHAIN 中删除一个 AIO_REQ_CHAIN 节点 (这里必须锁定 _G_aioqueue) ** 输 入 : paiorc AIO_REQ_CHAIN 节点 ** pplineHeader 创建后加入的链表表头地址 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __aioDeleteFd (AIO_REQ_CHAIN *paiorc, LW_LIST_LINE_HEADER *pplineHeader) { API_SemaphoreMPend(paiorc->aiorc_mutex, LW_OPTION_WAIT_INFINITE); __aioRemoveAllAiocb(paiorc, PX_ERROR, ECANCELED); /* 删除所有同文件描述符节点 */ API_SemaphoreMPost(paiorc->aiorc_mutex); _List_Line_Del(&paiorc->aiorc_line, pplineHeader); API_SemaphoreMDelete(&paiorc->aiorc_mutex); API_ThreadCondDestroy(&paiorc->aiorc_cond); __SHEAP_FREE(paiorc); }
/********************************************************************************************************* ** 函数名称: _ThreadStatusChangeCur ** 功能描述: 改变当前线程状态 (内核状态且关闭中断状态被调用) ** 输 入 : ptcbCur 当前 CPU ** 输 出 : NONE ** 全局变量: ** 调用模块: ** 注 意 : *********************************************************************************************************/ VOID _ThreadStatusChangeCur (PLW_CLASS_CPU pcpuCur) { PLW_CLASS_TCB ptcbCur; PLW_CLASS_TCB ptcb; PLW_CLASS_PCB ppcb; ptcbCur = pcpuCur->CPU_ptcbTCBCur; /* 当前线程 */ if (ptcbCur->TCB_plineStatusReqHeader) { /* 需要阻塞 */ if (__LW_THREAD_IS_READY(ptcbCur)) { ppcb = _GetPcb(ptcbCur); __DEL_FROM_READY_RING(ptcbCur, ppcb); /* 从就绪表中删除 */ } do { ptcb = _LIST_ENTRY(ptcbCur->TCB_plineStatusReqHeader, LW_CLASS_TCB, TCB_lineStatusPend); switch (ptcb->TCB_uiStatusChangeReq) { case LW_TCB_REQ_SUSPEND: ptcbCur->TCB_ulSuspendNesting++; ptcbCur->TCB_usStatus |= LW_THREAD_STATUS_SUSPEND; break; case LW_TCB_REQ_STOP: ptcbCur->TCB_ulStopNesting++; ptcbCur->TCB_usStatus |= LW_THREAD_STATUS_STOP; break; case LW_TCB_REQ_WDEATH: ptcbCur->TCB_usStatus |= LW_THREAD_STATUS_WDEATH; break; } ptcb->TCB_ptcbWaitStatus = LW_NULL; ptcb->TCB_uiStatusChangeReq = 0; /* 请求修改的状态成功 */ _List_Line_Del(&ptcb->TCB_lineStatusPend, &ptcbCur->TCB_plineStatusReqHeader); if (!__LW_THREAD_IS_READY(ptcb)) { /* 如果没有就绪, 取消 WSTAT */ ptcb->TCB_usStatus &= ~LW_THREAD_STATUS_WSTAT; if (__LW_THREAD_IS_READY(ptcb)) { ptcb->TCB_ucSchedActivate = LW_SCHED_ACT_INTERRUPT; /* 中断激活方式 */ ppcb = _GetPcb(ptcb); __ADD_TO_READY_RING(ptcb, ppcb); } } } while (ptcbCur->TCB_plineStatusReqHeader); } }
/********************************************************************************************************* ** 函数名称: API_PciDevDelete ** 功能描述: 删除一个 PCI 设备 ** 输 入 : hHandle 设备控制句柄 ** 输 出 : ERROR or OK ** 全局变量: ** 调用模块: API 函数 *********************************************************************************************************/ LW_API INT API_PciDevDelete (PCI_DEV_HANDLE hHandle) { PLW_LIST_LINE plineTemp = LW_NULL; PCI_DEV_HANDLE hDevHandle = LW_NULL; if (hHandle == LW_NULL) { __PCI_DEV_LOCK(); for (plineTemp = _GplinePciDevHeader; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { hDevHandle = _LIST_ENTRY(plineTemp, PCI_DEV_TCB, PDT_lineDevNode); _List_Line_Del(&hDevHandle->PDT_lineDevNode, &_GplinePciDevHeader); _GuiPciDevTotalNum -= 1; __SHEAP_FREE(hDevHandle); } __PCI_DEV_UNLOCK(); return (ERROR_NONE); } hDevHandle = API_PciDevHandleGet(hHandle->PDT_iDevBus, hHandle->PDT_iDevDevice, hHandle->PDT_iDevFunction); if ((hDevHandle == LW_NULL) || (hDevHandle != hHandle)) { return (PX_ERROR); } __PCI_DEV_LOCK(); _List_Line_Del(&hHandle->PDT_lineDevNode, &_GplinePciDevHeader); _GuiPciDevTotalNum -= 1; __PCI_DEV_UNLOCK(); __SHEAP_FREE(hHandle); return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: __resDelRawHook ** 功能描述: 从资源管理器去除一个原始资源 ** 输 入 : presraw 原始资源缓冲 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ VOID __resDelRawHook (PLW_RESOURCE_RAW presraw) { if (!presraw) { return; } if (presraw->RESRAW_bIsInstall == LW_FALSE) { /* 必须是安装成功的 */ return; } __LW_RESRAW_LOCK(); _List_Line_Del(&presraw->RESRAW_lineManage, &_G_plineResRaw); presraw->RESRAW_bIsInstall = LW_FALSE; __LW_RESRAW_UNLOCK(); }
/********************************************************************************************************* ** 函数名称: __ram_truncate ** 功能描述: ramfs 截断一个文件 ** 输 入 : pramn 文件节点 ** stOft 阶段点 ** 输 出 : 缩短结果 ** 全局变量: ** 调用模块: *********************************************************************************************************/ VOID __ram_truncate (PRAM_NODE pramn, size_t stOft) { size_t stTemp = 0; PLW_LIST_LINE plineTemp; PLW_LIST_LINE plineDel; PRAM_VOLUME pramfs = pramn->RAMN_pramfs; for (plineTemp = pramn->RAMN_plineBStart; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { if (stOft <= stTemp) { /* 从此块开始删除 */ break; } else { stTemp += __RAM_BDATASIZE; /* 文件内容指针向前移动 */ } } if (plineTemp) { /* 需要截断 */ if (plineTemp == pramn->RAMN_plineBStart) { /* 从第一个块开始删除 */ pramn->RAMN_plineBStart = LW_NULL; pramn->RAMN_plineBEnd = LW_NULL; } else if (plineTemp == pramn->RAMN_plineBEnd) { /* 删除结束块 */ pramn->RAMN_plineBEnd = _list_line_get_prev(plineTemp); } do { plineDel = plineTemp; plineTemp = _list_line_get_next(plineTemp); _List_Line_Del(plineDel, &pramn->RAMN_plineBStart); __RAM_BFREE(plineTemp); pramfs->RAMFS_ulCurBlk--; pramn->RAMN_ulCnt--; } while (plineTemp); pramn->RAMN_stSize = stOft; /* 记录新的文件大小 */ pramn->RAMN_stVSize = stOft; pramn->RAMN_prambCookie = LW_NULL; /* cookie 未知 */ } }
/********************************************************************************************************* ** 函数名称: __aioRemoveAllAiocb ** 功能描述: 将指定的 aiocb 下属的所有 aio req chain 节点移除 (这里必须锁定 _G_aioqueue 与 paiorc) ** 输 入 : paiorc aio req chain 节点 ** iError 保存的返回值 ** iErrNo 保存的错误号 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static INT __aioRemoveAllAiocb (AIO_REQ_CHAIN *paiorc, INT iError, INT iErrNo) { struct aioreq *paioreqTemp; struct aiocb *paiocbTemp; while (paiorc->aiorc_plineaiocb) { paioreqTemp = _LIST_ENTRY(paiorc->aiorc_plineaiocb, struct aioreq, aioreq_line); paiocbTemp = _LIST_ENTRY(paioreqTemp, struct aiocb, aio_req); _List_Line_Del(paiorc->aiorc_plineaiocb, &paiorc->aiorc_plineaiocb); paioreqTemp->aioreq_error = iErrNo; paioreqTemp->aioreq_return = iError; if (paiocbTemp->aio_pwait) { __aioDetachWait(paiocbTemp, LW_NULL); /* detach wait 关联 */ } } return (AIO_CANCELED); }
/********************************************************************************************************* ** 函数名称: _hotplugClose ** 功能描述: 关闭热插拔消息文件 ** 输 入 : photplugfil 热插拔消息文件 ** 输 出 : ERROR ** 全局变量: ** 调用模块: *********************************************************************************************************/ static INT _hotplugClose (PLW_HOTPLUG_FILE photplugfil) { if (photplugfil) { HOTPLUG_DEV_LOCK(); _List_Line_Del(&photplugfil->HOTPFIL_lineManage, &_G_hotplugdev.HOTPDEV_plineFile); HOTPLUG_DEV_UNLOCK(); _bmsgDelete(photplugfil->HOTPFIL_pbmsg); if (LW_DEV_GET_USE_COUNT(&_G_hotplugdev.HOTPDEV_devhdrHdr)) { LW_DEV_DEC_USE_COUNT(&_G_hotplugdev.HOTPDEV_devhdrHdr); } API_SemaphoreBDelete(&photplugfil->HOTPFIL_ulReadSync); __SHEAP_FREE(photplugfil); return (ERROR_NONE); } else { return (PX_ERROR); } }
/********************************************************************************************************* ** 函数名称: __rtChangeCallback ** 功能描述: 修改一个 sylixos 路由条目(在 TCPIP 上下文中执行) ** 输 入 : ipaddrDest 目的地址 ** uiFlag flag ** pcNetifName 路由设备接口名 ** 输 出 : ERROR ** 全局变量: ** 调用模块: *********************************************************************************************************/ static INT __rtChangeCallback (ip_addr_t *pipaddrDest, UINT uiFlag, CPCHAR pcNetifName) { PLW_RT_ENTRY prte; prte = __rtFind(pipaddrDest, 0); if (prte) { INT iHash = LW_RT_HASHINDEX(&prte->RTE_ipaddrDest); if (prte->RTE_uiFlag & LW_RT_FLAG_U) { _G_uiActiveNum--; } _G_uiTotalNum--; LW_RT_CACHE_INVAL(prte); _List_Line_Del(&prte->RTE_lineManage, &_G_plineRtHashHeader[iHash]); prte->RTE_ipaddrDest = *pipaddrDest; prte->RTE_pnetif = netif_find((PCHAR)pcNetifName); prte->RTE_uiFlag = uiFlag; lib_strlcpy(prte->RTE_cNetifName, pcNetifName, IF_NAMESIZE); if (prte->RTE_pnetif) { prte->RTE_uiFlag |= LW_RT_FLAG_U; /* 路由有效 */ _G_uiActiveNum++; } _G_uiTotalNum++; iHash = LW_RT_HASHINDEX(&prte->RTE_ipaddrDest); _List_Line_Add_Ahead(&prte->RTE_lineManage, &_G_plineRtHashHeader[iHash]); return (ERROR_NONE); } _ErrorHandle(EINVAL); return (PX_ERROR); }
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 */ );
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); }
/********************************************************************************************************* ** 函数名称: __pthreadDataDeleteByThread ** 功能描述: 删除所有与当前线程相关的内部数据节点. ** 输 入 : NONE ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __pthreadDataDeleteByThread (LW_OBJECT_HANDLE ulId, PVOID pvRetVal, PLW_CLASS_TCB ptcbDel) { __PX_KEY_NODE *pkeyn; __PX_KEY_DATA *pkeyd; LW_OBJECT_HANDLE ulMe = ptcbDel->TCB_ulId; __PX_CONTEXT *pctx = _posixCtxTryGet(ptcbDel); /* 不存在则不创建 */ PLW_LIST_LINE plineTempK; PLW_LIST_LINE plineTempD; PVOID pvPrevValue; BOOL bCall = LW_TRUE; #if LW_CFG_MODULELOADER_EN > 0 LW_LD_VPROC *pvprocDel; #endif /* LW_CFG_MODULELOADER_EN */ if (pctx == LW_NULL) { /* 不是 posix 线程 */ return; } #if LW_CFG_MODULELOADER_EN > 0 pvprocDel = __LW_VP_GET_TCB_PROC(ptcbDel); if (pvprocDel && pvprocDel->VP_bForceTerm) { /* 进程不需要执行 destructor */ bCall = LW_FALSE; } #endif /* LW_CFG_MODULELOADER_EN */ /* * 线程删除, 需要遍历所有 key 键的私有数据表, 删除与本线程相关的私有数据 */ __re_check: __PX_LOCK(); /* 锁住 posix 库 */ for (plineTempK = _G_plineKeyHeader; plineTempK != LW_NULL; plineTempK = _list_line_get_next(plineTempK)) { /* 遍历所有 key 键 */ pkeyn = (__PX_KEY_NODE *)plineTempK; plineTempD = pkeyn->PKEYN_plineKeyHeader; /* 遍历 key 键内的所有节点 */ while (plineTempD) { pkeyd = (__PX_KEY_DATA *)plineTempD; plineTempD = _list_line_get_next(plineTempD); if (pkeyd->PKEYD_ulOwner == ulMe) { /* 是否为当前线程数据节点 */ if (pkeyd->PKEYD_pvData) { /* 需要调用 destructor */ pvPrevValue = pkeyd->PKEYD_pvData; pkeyd->PKEYD_pvData = LW_NULL; /* 下次不再调用 destructor */ __PX_UNLOCK(); /* 解锁 posix 库 */ if (pkeyn->PKEYN_pfuncDestructor && bCall) { /* 调用删除函数 */ LW_SOFUNC_PREPARE(pkeyn->PKEYN_pfuncDestructor); pkeyn->PKEYN_pfuncDestructor(pvPrevValue); } goto __re_check; /* 重新检查 */ } _List_Line_Del(&pkeyd->PKEYD_lineManage, &pkeyn->PKEYN_plineKeyHeader); /* 从链表中删除 */ __SHEAP_FREE(pkeyd); /* 释放线程私有数据内存 */ } } } __PX_UNLOCK(); /* 解锁 posix 库 */ }