/********************************************************************************************************* ** 函数名称: __ram_getbuf ** 功能描述: ramfs 读取文件内容 ** 输 入 : pramn 文件节点 ** stOft 偏移量 ** pstBlkOft 获取的 block 内部偏移 ** 输 出 : 获取的缓冲区 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static PRAM_BUFFER __ram_getbuf (PRAM_NODE pramn, size_t stOft, size_t *pstBlkOft) { #define RAM_BCHK_VALID(x) if (x == LW_NULL) { _ErrorHandle(ENOSPC); return (LW_NULL); } PLW_LIST_LINE plineTemp; ULONG i; ULONG ulFoot = __ARCH_ULONG_MAX; ULONG ulBlkIndex; if (pramn->RAMN_plineBStart == LW_NULL) { _ErrorHandle(ENOSPC); return (LW_NULL); } ulBlkIndex = (ULONG)(stOft / __RAM_BDATASIZE); *pstBlkOft = (ULONG)(stOft % __RAM_BDATASIZE); if (pramn->RAMN_prambCookie) { /* 首先检查 cookie */ ulFoot = RAM_FOOT(pramn->RAMN_ulCookie, ulBlkIndex); if (ulFoot == 0ul) { return (pramn->RAMN_prambCookie); } } if (ulFoot < ulBlkIndex) { /* 通过 cookie 查找更快速 */ plineTemp = (PLW_LIST_LINE)pramn->RAMN_prambCookie; if (pramn->RAMN_ulCookie < ulBlkIndex) { for (i = 0; i < ulFoot; i++) { plineTemp = _list_line_get_next(plineTemp); RAM_BCHK_VALID(plineTemp); } } else { for (i = 0; i < ulFoot; i++) { plineTemp = _list_line_get_prev(plineTemp); RAM_BCHK_VALID(plineTemp); } } } else { /* 需要通过 start end 查询 */ REGISTER ULONG ulForward = ulBlkIndex; REGISTER ULONG ulBackward = pramn->RAMN_ulCnt - ulBlkIndex - 1; if (ulForward <= ulBackward) { /* 通过 start 指针查找更快 */ plineTemp = pramn->RAMN_plineBStart; for (i = 0; i < ulForward; i++) { plineTemp = _list_line_get_next(plineTemp); RAM_BCHK_VALID(plineTemp); } } else { /* 通过 end 指针查找更快 */ plineTemp = pramn->RAMN_plineBEnd; for (i = 0; i < ulBackward; i++) { plineTemp = _list_line_get_prev(plineTemp); RAM_BCHK_VALID(plineTemp); } } } pramn->RAMN_prambCookie = (PRAM_BUFFER)plineTemp; pramn->RAMN_ulCookie = ulBlkIndex; return (pramn->RAMN_prambCookie); }
/********************************************************************************************************* ** 函数名称: __aioInsertAiocb ** 功能描述: 将指定的 aiocb 按优先级插入到 aio req chain 节点下属的队列中 (这里必须锁定 paiorc) ** 输 入 : paiorc 目标 aio req chain 节点 ** paiocb 指定的 aiocb ** 输 出 : NONE ** 全局变量: ** 调用模块: ** 注 意 : 优先级数值越高, 越靠近表头, 请求越先被执行. *********************************************************************************************************/ static VOID __aioInsertAiocb (AIO_REQ_CHAIN *paiorc, struct aiocb *paiocb) { PLW_LIST_LINE plineTemp; struct aioreq *paioreqTemp; struct aiocb *paiocbTemp; if (paiorc->aiorc_plineaiocb == LW_NULL) { /* 链表空, 插入表头即可 */ _List_Line_Add_Ahead(&paiocb->aio_req.aioreq_line, &paiorc->aiorc_plineaiocb); return; } plineTemp = paiorc->aiorc_plineaiocb; do { paioreqTemp = _LIST_ENTRY(plineTemp, struct aioreq, aioreq_line); paiocbTemp = _LIST_ENTRY(paioreqTemp, struct aiocb, aio_req); if (paiocbTemp->aio_reqprio < paiocb->aio_reqprio) { /* 是否可以插入 */ if (plineTemp == paiorc->aiorc_plineaiocb) { /* 是否为表头位置 */ _List_Line_Add_Ahead(&paiocb->aio_req.aioreq_line, &paiorc->aiorc_plineaiocb); /* 插入表头即可 */ break; } else { _List_Line_Add_Left(&paiocb->aio_req.aioreq_line, plineTemp); /* 插入当前节点的左侧 */ } break; } if (_list_line_get_next(plineTemp) == LW_NULL) { /* 最后一项 */ _List_Line_Add_Right(&paiocb->aio_req.aioreq_line, plineTemp); /* 插入当前节点的右侧 */ break; } else { plineTemp = _list_line_get_next(plineTemp); /* 继续检查下一项 */ } } while (1); }
/********************************************************************************************************* ** 函数名称: __rtMatch ** 功能描述: 匹配一个 sylixos 路由条目 (优先选择主机路由, 然后选择网络路由) ** 输 入 : pipaddrDest 目标地址 ** 输 出 : 如果查询到, 则返回路由表节点 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static PLW_RT_ENTRY __rtMatch (const ip_addr_t *pipaddrDest) { INT iHash = LW_RT_HASHINDEX(pipaddrDest); PLW_LIST_LINE plineTemp; PLW_RT_ENTRY prte; PLW_RT_ENTRY prteNet = LW_NULL; /* 缓冲遍历是产生的网络地址 */ for (plineTemp = _G_plineRtHashHeader[iHash]; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { prte = (PLW_RT_ENTRY)plineTemp; if (prte->RTE_uiFlag & LW_RT_FLAG_U) { /* 路由节点有效 */ if ((prte->RTE_uiFlag & LW_RT_FLAG_H) && (prte->RTE_ipaddrDest.addr == pipaddrDest->addr)) { /* 主机匹配检查 */ return (prte); } else if ((prteNet == LW_NULL) && (ip_addr_netcmp(pipaddrDest, &(prte->RTE_pnetif->ip_addr), &(prte->RTE_pnetif->netmask)))) {/* 网络匹配检查 */ prteNet = prte; } } } return (prteNet); }
/********************************************************************************************************* ** 函数名称: _hotplugDevPutMsg ** 功能描述: 产生一条 hotplug 消息 ** 输 入 : iMsg 信息类型 ** pvMsg 需要保存的消息 ** stSize 消息长度. ** 输 出 : NONE ** 全局变量: ** 调用模块: API 函数 *********************************************************************************************************/ VOID _hotplugDevPutMsg (INT iMsg, CPVOID pvMsg, size_t stSize) { PLW_LIST_LINE plineTemp; PLW_HOTPLUG_FILE photplugfil; BOOL bWakeup = LW_FALSE; if ((_G_hotplugdev.HOTPDEV_ulMutex == LW_OBJECT_HANDLE_INVALID) || (_G_hotplugdev.HOTPDEV_plineFile == LW_NULL)) { return; } HOTPLUG_DEV_LOCK(); for (plineTemp = _G_hotplugdev.HOTPDEV_plineFile; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { photplugfil = _LIST_ENTRY(plineTemp, LW_HOTPLUG_FILE, HOTPFIL_lineManage); if ((photplugfil->HOTPFIL_iMsg == iMsg) || (photplugfil->HOTPFIL_iMsg == LW_HOTPLUG_MSG_ALL)) { _bmsgPut(photplugfil->HOTPFIL_pbmsg, pvMsg, stSize); API_SemaphoreBPost(photplugfil->HOTPFIL_ulReadSync); bWakeup = LW_TRUE; } } HOTPLUG_DEV_UNLOCK(); if (bWakeup) { SEL_WAKE_UP_ALL(&_G_hotplugdev.HOTPDEV_selwulList, SELREAD); } }
/********************************************************************************************************* ** 函数名称: __pthreadDataGet ** 功能描述: 获取指定 key 在当前线程内部数据节点. ** 输 入 : lId 键id ** ppvData 初始数据(返回) ** 输 出 : ERROR CODE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static INT __pthreadDataGet (long lId, void **ppvData) { __PX_KEY_NODE *pkeyn = (__PX_KEY_NODE *)lId; __PX_KEY_DATA *pkeyd; LW_OBJECT_HANDLE ulMe = API_ThreadIdSelf(); PLW_LIST_LINE plineTemp; if (ppvData == LW_NULL) { errno = EINVAL; return (EINVAL); } if (pkeyn == LW_NULL) { /* 没有 key 键 */ errno = EINVAL; return (EINVAL); } *ppvData = LW_NULL; __PX_KEY_LOCK(pkeyn); /* 锁住 key 键 */ for (plineTemp = pkeyn->PKEYN_plineKeyHeader; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { pkeyd = (__PX_KEY_DATA *)plineTemp; /* 链表是 KEY DATA 的第一个元素*/ if (pkeyd->PKEYD_ulOwner == ulMe) { /* 找到对应当前线程的数据 */ *ppvData = pkeyd->PKEYD_pvData; break; } } __PX_KEY_UNLOCK(pkeyn); /* 解锁 key 键 */ return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: __resPidReclaimOnlyRaw ** 功能描述: 从资源管理器删除对应进程的原始资源 (内核对象和文件不回收) ** 输 入 : pid 进程号 ** 输 出 : 是否成功, 如果不成功证明这个进程还有线程在运行. ** 全局变量: ** 调用模块: *********************************************************************************************************/ INT __resPidReclaimOnlyRaw (pid_t pid) { PLW_RESOURCE_RAW presraw; PLW_LIST_LINE plineTemp; if (pid == 0) { return (ERROR_NONE); /* 内核, 不执行回收操作 */ } __LW_RESRAW_LOCK(); plineTemp = _G_plineResRaw; while (plineTemp) { presraw = (PLW_RESOURCE_RAW)plineTemp; plineTemp = _list_line_get_next(plineTemp); if (presraw->RESRAW_pid == pid) { presraw->RESRAW_pfuncFree(presraw->RESRAW_pvArg[0], presraw->RESRAW_pvArg[1], presraw->RESRAW_pvArg[2], presraw->RESRAW_pvArg[3], presraw->RESRAW_pvArg[4], presraw->RESRAW_pvArg[5]); /* 释放原始资源 */ } } __LW_RESRAW_UNLOCK(); 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); }
/********************************************************************************************************* ** 函数名称: __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); }
/********************************************************************************************************* ** 函数名称: __rtFind ** 功能描述: 遍历 sylixos 路由条目 ** 输 入 : pfuncHook 遍历回调函数 ** pvArg0...4 参数 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __rtTraversal (VOIDFUNCPTR pfuncHook, PVOID pvArg0, PVOID pvArg1, PVOID pvArg2, PVOID pvArg3, PVOID pvArg4) { INT i; PLW_LIST_LINE plineTemp; PLW_RT_ENTRY prte; for (i = 0; i < LW_RT_TABLESIZE; i++) { for (plineTemp = _G_plineRtHashHeader[i]; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { prte = (PLW_RT_ENTRY)plineTemp; if (prte->RTE_pnetif) { prte->RTE_uiFlag |= LW_RT_FLAG_U; /* 路由有效 */ if ((prte->RTE_ipaddrDest.addr != IPADDR_BROADCAST) && !ip_addr_netcmp(&prte->RTE_ipaddrDest, &(prte->RTE_pnetif->ip_addr), &(prte->RTE_pnetif->netmask))) { /* 不在同一网络 */ prte->RTE_uiFlag |= LW_RT_FLAG_G; /* 间接路由 */ } else { prte->RTE_uiFlag &= ~LW_RT_FLAG_G; } } pfuncHook(prte, pvArg0, pvArg1, pvArg2, pvArg3, pvArg4); } } }
/********************************************************************************************************* ** 函数名称: API_PciDevHandleGet ** 功能描述: 获取一个设备的句柄 ** 输 入 : iBus 总线号 ** iDevice 设备号 ** iFunction 功能号 ** 输 出 : 设备控制句柄 ** 全局变量: ** 调用模块: API 函数 *********************************************************************************************************/ LW_API PCI_DEV_HANDLE API_PciDevHandleGet (INT iBus, INT iDevice, INT iFunction) { PLW_LIST_LINE plineTemp = LW_NULL; PCI_DEV_HANDLE hDevHandle = LW_NULL; hDevHandle = 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); if ((hDevHandle->PDT_iDevBus == iBus ) && (hDevHandle->PDT_iDevDevice == iDevice ) && (hDevHandle->PDT_iDevFunction == iFunction)) { break; } } __PCI_DEV_UNLOCK(); if (plineTemp) { return (hDevHandle); } else { return (LW_NULL); } }
/********************************************************************************************************* ** 函数名称: __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 未知 */ } }
/********************************************************************************************************* ** 函数名称: __aioAttachWait ** 功能描述: 向指定的 aiocb 中连接 wait 信息 (这里必须锁定 _G_aioqueue) ** 输 入 : paiocb 指定的 aiocb ** paiowait wait 信息 ** 输 出 : ERROR or OK ** 全局变量: ** 调用模块: *********************************************************************************************************/ INT __aioAttachWait (const struct aiocb *paiocb, struct aiowait *paiowait) { PLW_LIST_LINE plineTempAiorc; PLW_LIST_LINE plineTempAiocb; AIO_REQ_CHAIN *paiorc; struct aioreq *paioreqTemp; struct aiocb *paiocbTemp; BOOL bIsOk = LW_FALSE; for (plineTempAiorc = _G_aioqueue.aioq_plinework; plineTempAiorc != LW_NULL; plineTempAiorc = _list_line_get_next(plineTempAiorc)) { paiorc = _LIST_ENTRY(plineTempAiorc, AIO_REQ_CHAIN, aiorc_line); if (paiorc->aiorc_fildes == paiocb->aio_fildes) { API_SemaphoreMPend(paiorc->aiorc_mutex, LW_OPTION_WAIT_INFINITE); for (plineTempAiocb = paiorc->aiorc_plineaiocb; plineTempAiocb != LW_NULL; plineTempAiocb = _list_line_get_next(plineTempAiocb)) { paioreqTemp = _LIST_ENTRY(plineTempAiocb, struct aioreq, aioreq_line); paiocbTemp = _LIST_ENTRY(paioreqTemp, struct aiocb, aio_req); if (paiocbTemp == paiocb) { if (paiocbTemp->aio_pwait) { /* 不允许重复保存 */ API_SemaphoreMPost(paiorc->aiorc_mutex); return (PX_ERROR); } paiocbTemp->aio_pwait = paiowait; paiowait->aiowt_paiocb = paiocbTemp; bIsOk = LW_TRUE; break; } } API_SemaphoreMPost(paiorc->aiorc_mutex); break; } }
/********************************************************************************************************* ** 函数名称: __ram_unlink_dir ** 功能描述: ramfs 删除一个目录 ** 输 入 : plineDir 目录头链表 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __ram_unlink_dir (LW_LIST_LINE_HEADER plineDir) { PLW_LIST_LINE plineTemp; PRAM_NODE pramn; while (plineDir) { plineTemp = plineDir; plineDir = _list_line_get_next(plineDir); pramn = _LIST_ENTRY(plineTemp, RAM_NODE, RAMN_lineBrother); if (S_ISDIR(pramn->RAMN_mode) && pramn->RAMN_plineSon) { /* 目录文件 */ __ram_unlink_dir(pramn->RAMN_plineSon); /* 递归删除子目录 */ } __ram_unlink(pramn); } }
/********************************************************************************************************* ** 函数名称: __rtFind ** 功能描述: 查找一个 sylixos 路由条目 ** 输 入 : pipaddrDest 目标地址 ** ulFlag 需要满足的标志 ** 输 出 : 如果查询到, 则返回路由表节点 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static PLW_RT_ENTRY __rtFind (ip_addr_t *pipaddrDest, UINT ulFlag) { INT iHash = LW_RT_HASHINDEX(pipaddrDest); PLW_LIST_LINE plineTemp; PLW_RT_ENTRY prte; for (plineTemp = _G_plineRtHashHeader[iHash]; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { prte = (PLW_RT_ENTRY)plineTemp; if ((prte->RTE_ipaddrDest.addr == pipaddrDest->addr) && ((prte->RTE_uiFlag & ulFlag) == ulFlag)) { /* 满足条件直接返回 */ return (prte); } } return (LW_NULL); }
/********************************************************************************************************* ** 函数名称: __aioSearchFd ** 功能描述: 从指定的 AIO_REQ_CHAIN 中搜索与指定文件描述符相同的 aio req chain 节点. (这里必须锁定 _G_aioqueue) ** 输 入 : plineHeader 搜索链表头 ** iFd 文件描述符 ** 输 出 : 查找到的 aio req chain 节点 ** 全局变量: ** 调用模块: ** 注 意 : 这个函数 search 到的 aiorc 都是没有被 cancel 的. 如果被 cancel 了, 一定会有代理线程将 cancel 的 aiorc 删除. *********************************************************************************************************/ AIO_REQ_CHAIN *__aioSearchFd (LW_LIST_LINE_HEADER plineHeader, int iFd) { AIO_REQ_CHAIN *paiorc; PLW_LIST_LINE plineTemp; for (plineTemp = plineHeader; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { paiorc = _LIST_ENTRY(plineTemp, AIO_REQ_CHAIN, aiorc_line); if ((paiorc->aiorc_fildes == iFd) && (paiorc->aiorc_iscancel == 0)) { /* 注意, cancel的paiorc不返回 */ break; } } if (plineTemp) { return (paiorc); } else { return (LW_NULL); } }
/********************************************************************************************************* ** 函数名称: __rtNeifRemoveCallback ** 功能描述: 移除网络接口回调(网络安全) ** 输 入 : netif 网络接口 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __rtNeifRemoveCallback (struct netif *netif) { INT i; PLW_LIST_LINE plineTemp; PLW_RT_ENTRY prte; for (i = 0; i < LW_RT_TABLESIZE; i++) { for (plineTemp = _G_plineRtHashHeader[i]; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { prte = (PLW_RT_ENTRY)plineTemp; if (prte->RTE_pnetif == netif) { /* 对应的路由条目应该无效 */ prte->RTE_pnetif = LW_NULL; prte->RTE_uiFlag &= ~LW_RT_FLAG_U; LW_RT_CACHE_INVAL(prte); /* 无效对应 cache */ _G_uiActiveNum--; } } } }
/********************************************************************************************************* ** 函数名称: __tshellPciDevCmdShow ** 功能描述: 打印 PCI 设备列表 ** 输 入 : NONE ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __tshellPciDevCmdShow (VOID) { static PCHAR pcPciDevShowHdr = \ " INDEX BUS DEV FUNC VENDOR DEVICE SUBV SUBD DRVNAME\n" "------- ----- ----- ------ ------ ------ ------ ------ ------------------------\n"; PLW_LIST_LINE plineTemp = LW_NULL; PCI_DEV_HANDLE hDevHandle = LW_NULL; PCI_DRV_HANDLE hDrvHandle = LW_NULL; REGISTER INT i; printf("pci dev number total : %d\n", _GuiPciDevTotalNum); printf(pcPciDevShowHdr); __PCI_DEV_LOCK(); i = 0; for (plineTemp = _GplinePciDevHeader; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { hDevHandle = _LIST_ENTRY(plineTemp, PCI_DEV_TCB, PDT_lineDevNode); hDrvHandle = (PCI_DRV_HANDLE)hDevHandle->PDT_pvDevDriver; printf("%7d %5d %5d %6d %6x %6x %6x %6x %-24s\n", i, hDevHandle->PDT_iDevBus, hDevHandle->PDT_iDevDevice, hDevHandle->PDT_iDevFunction, hDevHandle->PDT_phDevHdr.PCIH_pcidHdr.PCID_usVendorId, hDevHandle->PDT_phDevHdr.PCIH_pcidHdr.PCID_usDeviceId, hDevHandle->PDT_phDevHdr.PCIH_pcidHdr.PCID_usSubVendorId, hDevHandle->PDT_phDevHdr.PCIH_pcidHdr.PCID_usSubSystemId, ((hDrvHandle == LW_NULL) ? "NULL" : hDrvHandle->PDT_cDrvName)); i += 1; } __PCI_DEV_UNLOCK(); fflush(stdout); /* 清空输出 */ }
/********************************************************************************************************* ** 函数名称: 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); }
/********************************************************************************************************* ** 函数名称: __rtNeifAddCallback ** 功能描述: 添加网络接口回调(网络安全) ** 输 入 : netif 网络接口 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __rtNeifAddCallback (struct netif *netif) { INT i; PLW_LIST_LINE plineTemp; PLW_RT_ENTRY prte; CHAR cNetifName[IF_NAMESIZE]; if_indextoname(netif->num, cNetifName); for (i = 0; i < LW_RT_TABLESIZE; i++) { for (plineTemp = _G_plineRtHashHeader[i]; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { prte = (PLW_RT_ENTRY)plineTemp; if (lib_strncmp(cNetifName, prte->RTE_cNetifName, IF_NAMESIZE) == 0) { prte->RTE_pnetif = netif; /* 对应的路由条目有效 */ prte->RTE_uiFlag |= LW_RT_FLAG_U; _G_uiActiveNum++; } } } }
/********************************************************************************************************* ** 函数名称: _hotplugThread ** 功能描述: hotplug 事件处理线程 ** 输 入 : NONE ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID _hotplugThread (VOID) { ULONG ulError; for (;;) { ulError = _jobQueueExec(&_G_jobqHotplug, LW_HOTPLUG_SEC * LW_TICK_HZ); if (ulError) { /* 需要处理轮询事件 */ PLW_HOTPLUG_POLLNODE phppn; 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) { phppn->HPPN_pfunc(phppn->HPPN_pvArg); /* 调用先前安装的循环检测函数 */ } } __HOTPLUG_UNLOCK(); /* unlock hotplug poll list */ } } }
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); }
/********************************************************************************************************* ** 函数名称: __resPidReclaim ** 功能描述: 从资源管理器删除对应进程的全部资源 (需要等待所有进程内线程结束) ** 输 入 : pid 进程号 ** 输 出 : 是否成功, 如果不成功证明这个进程还有线程在运行. ** 全局变量: ** 调用模块: *********************************************************************************************************/ INT __resPidReclaim (pid_t pid) { INT i; PLW_RESOURCE_H presh; PLW_RESOURCE_RAW presraw; PLW_LIST_LINE plineTemp; if (pid == 0) { return (ERROR_NONE); /* 内核, 不执行回收操作 */ } __LW_RESRAW_LOCK(); plineTemp = _G_plineResRaw; while (plineTemp) { presraw = (PLW_RESOURCE_RAW)plineTemp; plineTemp = _list_line_get_next(plineTemp); if (presraw->RESRAW_pid == pid) { presraw->RESRAW_pfuncFree(presraw->RESRAW_pvArg[0], presraw->RESRAW_pvArg[1], presraw->RESRAW_pvArg[2], presraw->RESRAW_pvArg[3], presraw->RESRAW_pvArg[4], presraw->RESRAW_pvArg[5]); /* 释放原始资源 */ } } __LW_RESRAW_UNLOCK(); vprocIoReclaim(pid, LW_FALSE); /* 回收进程所有打开的文件 */ #if LW_CFG_VMM_EN > 0 API_VmmMmapReclaim(pid); #endif /* LW_CFG_VMM_EN > 0 */ for (i = 0; i < LW_CFG_MAX_THREAD_POOLS; i++) { presh = &_G_reshThreadPoolBuffer[i]; if ((presh->RESH_pid == pid) && !presh->RESH_bIsGlobal) { API_ThreadPoolDelete(&presh->RESH_ulHandle); } } for (i = 0; i < LW_CFG_MAX_EVENTS; i++) { /* 处理事件 */ presh = &_G_reshEventBuffer[i]; if ((presh->RESH_pid == pid) && !presh->RESH_bIsGlobal) { if (_ObjectGetClass(presh->RESH_ulHandle) == _OBJECT_MSGQUEUE) { API_MsgQueueDelete(&presh->RESH_ulHandle); } else { API_SemaphoreDelete(&presh->RESH_ulHandle); } } } for (i = 0; i < LW_CFG_MAX_EVENTSETS; i++) { /* 处理事件组 */ presh = &_G_reshEventsetBuffer[i]; if ((presh->RESH_pid == pid) && !presh->RESH_bIsGlobal) { API_EventSetDelete(&presh->RESH_ulHandle); } } for (i = 0; i < LW_CFG_MAX_TIMERS; i++) { /* 处理定时器 */ presh = &_G_reshTimerBuffer[i]; if ((presh->RESH_pid == pid) && !presh->RESH_bIsGlobal) { API_TimerDelete(&presh->RESH_ulHandle); } } for (i = 0; i < LW_CFG_MAX_RMSS; i++) { /* 处理 RMS */ presh = &_G_reshRmsBuffer[i]; if ((presh->RESH_pid == pid) && !presh->RESH_bIsGlobal) { API_RmsDeleteEx(&presh->RESH_ulHandle, LW_TRUE); } } for (i = 0; i < LW_CFG_MAX_PARTITIONS; i++) { /* 处理 PATITIONS */ presh = &_G_reshPartitionBuffer[i]; if ((presh->RESH_pid == pid) && !presh->RESH_bIsGlobal) { API_PartitionDeleteEx(&presh->RESH_ulHandle, LW_TRUE); } } for (i = 0; i < LW_CFG_MAX_REGIONS; i++) { /* 最后处理可变内存 */ presh = &_G_reshRegionBuffer[i]; if ((presh->RESH_pid == pid) && !presh->RESH_bIsGlobal) { API_RegionDeleteEx(&presh->RESH_ulHandle, LW_TRUE); } } return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: API_InterVectorConnectEx ** 功能描述: 设置系统指定向量中断服务 ** 输 入 : ulVector 中断向量号 ** pfuncIsr 服务函数 ** pfuncClear 附加中断清除函数(可为 NULL) ** pvArg 服务函数参数 ** pcName 中断服务名称 ** 输 出 : ERROR CODE ** 全局变量: ** 调用模块: API 函数 *********************************************************************************************************/ LW_API ULONG API_InterVectorConnectEx (ULONG ulVector, PINT_SVR_ROUTINE pfuncIsr, VOIDFUNCPTR pfuncClear, PVOID pvArg, CPCHAR pcName) { INTREG iregInterLevel; BOOL bNeedFree; PLW_LIST_LINE plineTemp; PLW_CLASS_INTACT piactionOld; 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 (_Object_Name_Invalid(pcName)) { /* 检查名字有效性 */ _DebugHandle(__ERRORMESSAGE_LEVEL, "name too long.\r\n"); _ErrorHandle(ERROR_KERNEL_PNAME_TOO_LONG); return (ERROR_KERNEL_PNAME_TOO_LONG); } 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); } piaction = (PLW_CLASS_INTACT)__KHEAP_ALLOC(sizeof(LW_CLASS_INTACT)); if (piaction == LW_NULL) { _DebugHandle(__ERRORMESSAGE_LEVEL, "kernel low memory.\r\n"); _ErrorHandle(ERROR_KERNEL_LOW_MEMORY); return (ERROR_KERNEL_LOW_MEMORY); } lib_bzero(piaction, sizeof(LW_CLASS_INTACT)); piaction->IACT_pfuncIsr = pfuncIsr; piaction->IACT_pfuncClear = pfuncClear; piaction->IACT_pvArg = pvArg; if (pcName) { lib_strcpy(piaction->IACT_cInterName, pcName); } else { piaction->IACT_cInterName[0] = PX_EOS; } pidesc = LW_IVEC_GET_IDESC(ulVector); LW_SPIN_LOCK_QUICK(&pidesc->IDESC_slLock, &iregInterLevel); /* 关闭中断同时锁住 spinlock */ if (LW_IVEC_GET_FLAG(ulVector) & LW_IRQ_FLAG_QUEUE) { /* 队列服务类型向量 */ for (plineTemp = pidesc->IDESC_plineAction; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { piactionOld = _LIST_ENTRY(plineTemp, LW_CLASS_INTACT, IACT_plineManage); if ((piactionOld->IACT_pfuncIsr == pfuncIsr) && (piactionOld->IACT_pvArg == pvArg)) { /* 中断处理函数是否被重复安装 */ break; } } if (plineTemp) { /* 此中断被重复安装 */ bNeedFree = LW_TRUE; } else { _List_Line_Add_Ahead(&piaction->IACT_plineManage, &pidesc->IDESC_plineAction); bNeedFree = LW_FALSE; } } else { /* 非队列服务式中断向量 */ if (pidesc->IDESC_plineAction) { piactionOld = _LIST_ENTRY(pidesc->IDESC_plineAction, LW_CLASS_INTACT, IACT_plineManage); piactionOld->IACT_pfuncIsr = piaction->IACT_pfuncIsr; piactionOld->IACT_pfuncClear = piaction->IACT_pfuncClear; piactionOld->IACT_pvArg = piaction->IACT_pvArg; lib_strcpy(piactionOld->IACT_cInterName, piaction->IACT_cInterName); bNeedFree = LW_TRUE; } else { _List_Line_Add_Ahead(&piaction->IACT_plineManage, &pidesc->IDESC_plineAction); bNeedFree = LW_FALSE; } } LW_SPIN_UNLOCK_QUICK(&pidesc->IDESC_slLock, iregInterLevel); /* 打开中断, 同时打开 spinlock */ if (bNeedFree) { __KHEAP_FREE(piaction); } _DebugFormat(__LOGMESSAGE_LEVEL, "IRQ %d : %s connect : 0x%p\r\n", (INT)ulVector, (pcName ? pcName : ""), (PVOID)pfuncIsr); return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: __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 库 */ }
/********************************************************************************************************* ** 函数名称: __ram_open ** 功能描述: ramfs 打开一个文件 ** 输 入 : pramfs 文件系统 ** pcName 文件名 ** ppramnFather 当无法找到节点时保存最接近的一个, 但寻找到节点时保存父系节点. LW_NULL 表示根 pbRoot 是否为根节点 ** pbLast 当匹配失败时, 是否是最后一级文件匹配失败 ** ppcTail 如果存在连接文件, 指向连接文件后的路径 ** 输 出 : 打开结果 ** 全局变量: ** 调用模块: *********************************************************************************************************/ PRAM_NODE __ram_open (PRAM_VOLUME pramfs, CPCHAR pcName, PRAM_NODE *ppramnFather, BOOL *pbRoot, BOOL *pbLast, PCHAR *ppcTail) { CHAR pcTempName[MAX_FILENAME_LENGTH]; PCHAR pcNext; PCHAR pcNode; PRAM_NODE pramn; PRAM_NODE pramnTemp; PLW_LIST_LINE plineTemp; PLW_LIST_LINE plineHeader; /* 当前目录头 */ if (ppramnFather == LW_NULL) { ppramnFather = &pramnTemp; /* 临时变量 */ } *ppramnFather = LW_NULL; if (*pcName == PX_ROOT) { /* 忽略根符号 */ lib_strlcpy(pcTempName, (pcName + 1), PATH_MAX); } else { lib_strlcpy(pcTempName, pcName, PATH_MAX); } if (pcTempName[0] == PX_EOS) { if (pbRoot) { *pbRoot = LW_TRUE; /* pcName 为根 */ } if (pbLast) { *pbLast = LW_FALSE; } return (LW_NULL); } else { if (pbRoot) { *pbRoot = LW_FALSE; /* pcName 不为根 */ } } pcNext = pcTempName; plineHeader = pramfs->RAMFS_plineSon; /* 从根目录开始搜索 */ do { pcNode = pcNext; pcNext = lib_index(pcNode, PX_DIVIDER); /* 移动到下级目录 */ if (pcNext) { /* 是否可以进入下一层 */ *pcNext = PX_EOS; pcNext++; /* 下一层的指针 */ } for (plineTemp = plineHeader; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { pramn = _LIST_ENTRY(plineTemp, RAM_NODE, RAMN_lineBrother); if (S_ISLNK(pramn->RAMN_mode)) { /* 链接文件 */ if (lib_strcmp(pramn->RAMN_pcName, pcNode) == 0) { goto __find_ok; /* 找到链接 */ } } else if (S_ISDIR(pramn->RAMN_mode)) { if (lib_strcmp(pramn->RAMN_pcName, pcNode) == 0) { /* 已经找到一级目录 */ break; } } else { if (lib_strcmp(pramn->RAMN_pcName, pcNode) == 0) { if (pcNext) { /* 还存在下级, 这里必须为目录 */ goto __find_error; /* 不是目录直接错误 */ } break; } } } if (plineTemp == LW_NULL) { /* 无法继续搜索 */ goto __find_error; } *ppramnFather = pramn; /* 从当前节点开始搜索 */ plineHeader = pramn->RAMN_plineSon; /* 从第一个儿子开始 */ } while (pcNext); /* 不存在下级目录 */ __find_ok: *ppramnFather = pramn->RAMN_pramnFather; /* 父系节点 */ /* * 计算 tail 的位置. */ if (ppcTail) { if (pcNext) { INT iTail = pcNext - pcTempName; *ppcTail = (PCHAR)pcName + iTail; /* 指向没有被处理的 / 字符 */ } else { *ppcTail = (PCHAR)pcName + lib_strlen(pcName); /* 指向最末尾 */ } } return (pramn); __find_error: if (pbLast) { if (pcNext == LW_NULL) { /* 最后一级查找失败 */ *pbLast = LW_TRUE; } else { *pbLast = LW_FALSE; } } return (LW_NULL); /* 无法找到节点 */ }
/********************************************************************************************************* ** 函数名称: __pthreadDataSet ** 功能描述: 设置指定 key 在当前线程内部数据节点. (无则创建) ** 输 入 : lId 键id ** pvData 初始数据 ** 输 出 : ERROR CODE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static INT __pthreadDataSet (long lId, const void *pvData) { __PX_KEY_NODE *pkeyn = (__PX_KEY_NODE *)lId; __PX_KEY_DATA *pkeyd; PLW_CLASS_TCB ptcbCur; LW_OBJECT_HANDLE ulMe; __PX_CONTEXT *pctx; PLW_LIST_LINE plineTemp; if (pkeyn == LW_NULL) { /* 没有 key 键 */ errno = EINVAL; return (EINVAL); } LW_TCB_GET_CUR_SAFE(ptcbCur); ulMe = ptcbCur->TCB_ulId; pctx = _posixCtxGet(ptcbCur); if (pctx == LW_NULL) { /* 没有线程上下文 */ errno = ENOMEM; return (EINVAL); } /* * 查找是否已经创建了相关私有数据 */ __PX_KEY_LOCK(pkeyn); /* 锁住 key 键 */ for (plineTemp = pkeyn->PKEYN_plineKeyHeader; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { pkeyd = (__PX_KEY_DATA *)plineTemp; /* 链表是 KEY DATA 的第一个元素*/ if (pkeyd->PKEYD_ulOwner == ulMe) { /* 找到对应当前线程的数据 */ pkeyd->PKEYD_pvData = (void *)pvData; break; } } __PX_KEY_UNLOCK(pkeyn); /* 解锁 key 键 */ if (plineTemp) { return (ERROR_NONE); /* 已经找到了对应的节点 */ } /* * 如果没有找到, 则需要新建私有数据 */ pkeyd = (__PX_KEY_DATA *)__SHEAP_ALLOC(sizeof(__PX_KEY_DATA)); /* 没有节点, 需要新建 */ if (pkeyd == LW_NULL) { errno = ENOMEM; return (ENOMEM); } pkeyd->PKEYD_lId = lId; /* 通过 id 反向查找 key */ pkeyd->PKEYD_pvData = (void *)pvData; pkeyd->PKEYD_ulOwner = ulMe; /* 记录线程 ID */ __PX_KEY_LOCK(pkeyn); /* 锁住 key 键 */ _List_Line_Add_Ahead(&pkeyd->PKEYD_lineManage, &pkeyn->PKEYN_plineKeyHeader); /* 加入对应 key 键链表 */ __PX_KEY_UNLOCK(pkeyn); /* 解锁 key 键 */ return (ERROR_NONE); }
/********************************************************************************************************* ** 函数名称: __procFsPowerAdapterRead ** 功能描述: procfs 读一个读取网络 adapter 文件 ** 输 入 : p_pfsn 节点控制块 ** pcBuffer 缓冲区 ** stMaxBytes 缓冲区大小 ** oft 文件指针 ** 输 出 : 实际读取的数目 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static ssize_t __procFsPowerAdapterRead (PLW_PROCFS_NODE p_pfsn, PCHAR pcBuffer, size_t stMaxBytes, off_t oft) { const CHAR cAdapterInfoHdr[] = "ADAPTER MAX-CHANNLE\n"; PCHAR pcFileBuffer; size_t stRealSize; /* 实际的文件内容大小 */ size_t stCopeBytes; /* * 由于预置内存大小为 0 , 所以打开后第一次读取需要手动开辟内存. */ pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn); if (pcFileBuffer == LW_NULL) { /* 还没有分配内存 */ size_t stNeedBufferSize = 0; PLW_LIST_LINE plineTemp; PLW_PM_ADAPTER pmadapter; __POWERM_LOCK(); for (plineTemp = _G_plinePMAdapter; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { stNeedBufferSize += 32; } __POWERM_UNLOCK(); stNeedBufferSize += sizeof(cAdapterInfoHdr); if (API_ProcFsAllocNodeBuffer(p_pfsn, stNeedBufferSize)) { _ErrorHandle(ENOMEM); return (0); } pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn); /* 重新获得文件缓冲区地址 */ stRealSize = bnprintf(pcFileBuffer, stNeedBufferSize, 0, cAdapterInfoHdr); /* 打印头信息 */ __POWERM_LOCK(); for (plineTemp = _G_plinePMAdapter; plineTemp != LW_NULL; plineTemp = _list_line_get_next(plineTemp)) { pmadapter = _LIST_ENTRY(plineTemp, LW_PM_ADAPTER, PMA_lineManage); stRealSize = bnprintf(pcFileBuffer, stNeedBufferSize, stRealSize, "%-14s %u\n", pmadapter->PMA_cName, pmadapter->PMA_uiMaxChan); } __POWERM_UNLOCK(); API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize); } else { stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn); } if (oft >= stRealSize) { _ErrorHandle(ENOSPC); return (0); } stCopeBytes = __MIN(stMaxBytes, (size_t)(stRealSize - oft)); /* 计算实际拷贝的字节数 */ lib_memcpy(pcBuffer, (CPVOID)(pcFileBuffer + oft), (UINT)stCopeBytes); return ((ssize_t)stCopeBytes); }