/*********************************************************************************************************
** 函数名称: __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 库 */
}
