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