/********************************************************************************************************* ** 函数名称: _rngBufPut ** 功能描述: 向一个 VxWorks 兼容 ring buffer 缓冲区写入最多 iMaxBytes 个字节 ** 输 入 : ** vxringid 缓冲区控制块地址 ** pcBuffer 读出数据存放位置 ** iMaxBytes 读出最多的字节数 ** 输 出 : 实际读出的字节数 ** 全局变量: ** 调用模块: *********************************************************************************************************/ INT _rngBufPut (VX_RING_ID vxringid, PCHAR pcBuffer, INT iNBytes) { REGISTER INT iBytesPut = 0; REGISTER INT iFromBuf = vxringid->VXRING_iFromBuf; REGISTER INT iBytes2; REGISTER INT iRngTemp = 0; if (iFromBuf > vxringid->VXRING_iToBuf) { /* pFromBuf is ahead of pToBuf. We can fill up to two bytes * before it */ iBytesPut = __MIN(iNBytes, iFromBuf - vxringid->VXRING_iToBuf - 1); lib_memcpy(&vxringid->VXRING_pcBuf[vxringid->VXRING_iToBuf], pcBuffer, iBytesPut); vxringid->VXRING_iToBuf += iBytesPut; } else if (iFromBuf == 0) { /* pFromBuf is at the beginning of the buffer. We can fill till * the next-to-last element */ iBytesPut = __MIN(iNBytes, vxringid->VXRING_iBufByteSize - vxringid->VXRING_iToBuf - 1); lib_memcpy(&vxringid->VXRING_pcBuf[vxringid->VXRING_iToBuf], pcBuffer, iBytesPut); vxringid->VXRING_iToBuf += iBytesPut; } else { /* pFromBuf has wrapped around, and its not 0, so we can fill * at least to the end of the ring buffer. Do so, then see if * we need to wrap and put more at the beginning of the buffer. */ iBytesPut = __MIN(iNBytes, vxringid->VXRING_iBufByteSize - vxringid->VXRING_iToBuf); lib_memcpy(&vxringid->VXRING_pcBuf[vxringid->VXRING_iToBuf], pcBuffer, iBytesPut); iRngTemp = vxringid->VXRING_iToBuf + iBytesPut; if (iRngTemp == vxringid->VXRING_iBufByteSize) { /* We need to wrap, and perhaps put some more chars */ iBytes2 = __MIN(iNBytes - iBytesPut, iFromBuf - 1); lib_memcpy(vxringid->VXRING_pcBuf, pcBuffer + iBytesPut, iBytes2); vxringid->VXRING_iToBuf = iBytes2; iBytesPut += iBytes2; } else { vxringid->VXRING_iToBuf = iRngTemp; } } return (iBytesPut); }
/********************************************************************************************************* ** 函数名称: archDbgBpInsert ** 功能描述: 插入一个断点. ** 输 入 : ulAddr 断点地址 ** stSize 断点大小 ** pulIns 返回的之前的指令 ** bLocal 是否仅更新当前 CPU I-CACHE ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ VOID archDbgBpInsert (addr_t ulAddr, size_t stSize, ULONG *pulIns, BOOL bLocal) { ULONG ulIns = ARM_BREAKPOINT_INS; lib_memcpy((PCHAR)pulIns, (PCHAR)ulAddr, stSize); /* memcpy 避免 arm 对齐问题 */ lib_memcpy((PCHAR)ulAddr, (PCHAR)&ulIns, stSize); #if LW_CFG_CACHE_EN > 0 if (bLocal) { API_CacheLocalTextUpdate((PVOID)ulAddr, stSize); } else { API_CacheTextUpdate((PVOID)ulAddr, stSize); } #endif /* LW_CFG_CACHE_EN > 0 */ }
/********************************************************************************************************* ** 函数名称: __tshellCharBackspace ** 功能描述: shell 收到退格键. ** 输 入 : iFd 文件描述符 ** cChar 键值 ** psicContext 当前输入上下文 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __tshellCharBackspace (INT iFd, CHAR cChar, __PSHELL_INPUT_CTX psicContext) { CHAR cBsCharList[3]; if (CTX_CURSOR == 0) { return; } if (CTX_CURSOR == CTX_TOTAL) { cBsCharList[0] = cChar; cBsCharList[1] = ' '; cBsCharList[2] = cChar; write(iFd, cBsCharList, 3); CTX_CURSOR--; CTX_TOTAL--; } else if (CTX_CURSOR < CTX_TOTAL) { write(iFd, &cChar, 1); lib_memcpy(&CTX_BUFFER[CTX_CURSOR - 1], &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR); CTX_BUFFER[CTX_TOTAL - 1] = ' '; CTX_CURSOR--; write(iFd, &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR); __tshellTtyCursorMoveLeft(iFd, CTX_TOTAL - CTX_CURSOR); CTX_TOTAL--; } }
/********************************************************************************************************* ** 函数名称: iw_handler_get_private ** 功能描述: 执行私有控制句柄 ** 输 入 : dev 网络接口 ** 输 出 : OK or ERROR ** 全局变量: ** 调用模块: *********************************************************************************************************/ int iw_handler_get_private (struct netif *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { struct iw_handler_def *handlers = (struct iw_handler_def *)dev->wireless_handlers; if (!handlers) { return (-EOPNOTSUPP); } /* Check if the driver has something to export */ if ((handlers->num_private_args == 0) || (handlers->private_args == NULL)) { return (-EOPNOTSUPP); } /* Check if there is enough buffer up there */ if (wrqu->data.length < handlers->num_private_args) { /* User space can't know in advance how large the buffer * needs to be. Give it a hint, so that we can support * any size buffer we want somewhat efficiently... */ wrqu->data.length = handlers->num_private_args; return (-E2BIG); } /* Set the number of available ioctls. */ wrqu->data.length = handlers->num_private_args; /* Copy structure to the user buffer. */ lib_memcpy(extra, handlers->private_args, sizeof(struct iw_priv_args) * wrqu->data.length); return (0); }
/********************************************************************************************************* ** 函数名称: __procFsYaffsRead ** 功能描述: procfs 读一个 yaffs 文件 ** 输 入 : p_pfsn 节点控制块 ** pcBuffer 缓冲区 ** stMaxBytes 缓冲区大小 ** oft 文件指针 ** 输 出 : 实际读取的数目 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static ssize_t __procFsYaffsRead (PLW_PROCFS_NODE p_pfsn, PCHAR pcBuffer, size_t stMaxBytes, off_t oft) { REGISTER PCHAR pcFileBuffer; size_t stRealSize; /* 实际的文件内容大小 */ size_t stCopeBytes; /* * 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小. */ pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn); if (pcFileBuffer == LW_NULL) { _ErrorHandle(ENOMEM); return (0); } stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn); if (stRealSize == 0) { /* 需要生成文件 */ /* * 在这里生成文件的内容 */ INT i = 0; PCHAR pcVolName; struct yaffs_dev *pyaffsDev; /* yaffs 挂载设备 */ do { pcVolName = yaffs_getdevname(i, &i); if (pcVolName == LW_NULL) { break; /* 没有其他的卷 */ } pyaffsDev = (struct yaffs_dev *)yaffs_getdev(pcVolName); if (pyaffsDev == LW_NULL) { break; /* 无法查询到设备节点 */ } /* * (__PROCFS_BUFFER_SIZE_YAFFS - stRealSize) 为文件缓冲区剩余的空间大小 */ stRealSize = __procFsYaffsPrint(pyaffsDev, pcVolName, pcFileBuffer, __PROCFS_BUFFER_SIZE_YAFFS, stRealSize); } while (i != PX_ERROR); API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize); /* 回写文件实际大小 */ } 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); }
/********************************************************************************************************* ** 函数名称: __ram_write ** 功能描述: ramfs 写入文件内容 ** 输 入 : pramn 文件节点 ** pvBuffer 缓冲区 ** stNBytes 需要读取的大小 ** stOft 偏移量 ** 输 出 : 读取的字节数 ** 全局变量: ** 调用模块: *********************************************************************************************************/ ssize_t __ram_write (PRAM_NODE pramn, CPVOID pvBuffer, size_t stNBytes, size_t stOft) { PRAM_BUFFER pramb; UINT8 *pucDest = (UINT8 *)pvBuffer; size_t stEnd = stOft + stNBytes; size_t stWrite = 0; size_t stStart; ULONG ulNBlk; ulNBlk = (ULONG)(stEnd / __RAM_BDATASIZE); if (stEnd % __RAM_BDATASIZE) { ulNBlk++; } if (__ram_automem(pramn, ulNBlk, stOft, stNBytes)) { return (0); /* 没有内存空间可供分配 */ } pramb = __ram_getbuf(pramn, stOft, &stStart); while (pramb && stNBytes) { size_t stBufSize = (__RAM_BDATASIZE - stStart); if (stBufSize >= stNBytes) { lib_memcpy(&pramb->RAMB_ucData[stStart], pucDest, stNBytes); stWrite += stNBytes; break; } else { lib_memcpy(&pramb->RAMB_ucData[stStart], pucDest, stBufSize); pucDest += stBufSize; stWrite += stBufSize; stNBytes -= stBufSize; stStart = 0; /* 下次从 0 开始 */ } pramb = __ram_getbuf_next(pramn); } if (pramn->RAMN_stSize < (stOft + stWrite)) { pramn->RAMN_stSize = (stOft + stWrite); if (pramn->RAMN_stVSize < pramn->RAMN_stSize) { pramn->RAMN_stVSize = pramn->RAMN_stSize; } } return ((ssize_t)stWrite); }
/********************************************************************************************************* ** 函数名称: _rngBufGet ** 功能描述: 从一个 VxWorks 兼容 ring buffer 缓冲区读出最多 iMaxBytes 个字节 ** 输 入 : ** vxringid 缓冲区控制块地址 ** pcBuffer 读出数据存放位置 ** iMaxBytes 读出最多的字节数 ** 输 出 : 实际读出的字节数 ** 全局变量: ** 调用模块: *********************************************************************************************************/ INT _rngBufGet (VX_RING_ID vxringid, PCHAR pcBuffer, INT iMaxBytes) { REGISTER INT iBytesGot = 0; REGISTER INT iToBuf = vxringid->VXRING_iToBuf; REGISTER INT iBytes2; REGISTER INT iRngTemp = 0; if (iToBuf >= vxringid->VXRING_iFromBuf) { /* pToBuf has not wrapped around */ iBytesGot = __MIN(iMaxBytes, iToBuf - vxringid->VXRING_iFromBuf); lib_memcpy(pcBuffer, &vxringid->VXRING_pcBuf[vxringid->VXRING_iFromBuf], iBytesGot); vxringid->VXRING_iFromBuf += iBytesGot; } else { /* pToBuf has wrapped around. Grab chars up to the end of the * buffer, then wrap around if we need to. */ iBytesGot = __MIN(iMaxBytes, vxringid->VXRING_iBufByteSize - vxringid->VXRING_iFromBuf); lib_memcpy(pcBuffer, &vxringid->VXRING_pcBuf[vxringid->VXRING_iFromBuf], iBytesGot); iRngTemp = vxringid->VXRING_iFromBuf + iBytesGot; /* If pFromBuf is equal to bufSize, we've read the entire buffer, * and need to wrap now. If bytesgot < maxbytes, copy some more chars * in now. */ if (iRngTemp == vxringid->VXRING_iBufByteSize) { iBytes2 = __MIN(iMaxBytes - iBytesGot, iToBuf); lib_memcpy(pcBuffer + iBytesGot, vxringid->VXRING_pcBuf, iBytes2); vxringid->VXRING_iFromBuf = iBytes2; iBytesGot += iBytes2; } else { vxringid->VXRING_iFromBuf = iRngTemp; } } return (iBytesGot); }
HRESULT InStreamRead(void *aData, UINT32 aSize, UINT32* aProcessedSize) { if (aSize > in_stream.remainingBytes) aSize = in_stream.remainingBytes; *aProcessedSize = aSize; lib_memcpy(aData, in_stream.data, aSize); // brcm modification in_stream.remainingBytes -= aSize; in_stream.data += aSize; return S_OK; }
/********************************************************************************************************* ** 函数名称: __ram_read ** 功能描述: ramfs 读取文件内容 ** 输 入 : pramn 文件节点 ** pvBuffer 缓冲区 ** stSize 缓冲区大小 ** stOft 偏移量 ** 输 出 : 读取的字节数 ** 全局变量: ** 调用模块: *********************************************************************************************************/ ssize_t __ram_read (PRAM_NODE pramn, PVOID pvBuffer, size_t stSize, size_t stOft) { PRAM_BUFFER pramb; UINT8 *pucDest = (UINT8 *)pvBuffer; size_t stDataLeft; size_t stNBytes; size_t stRead = 0; size_t stStart; if (pramn->RAMN_stVSize <= stOft) { /* 已经到文件末尾 */ return (0); } stDataLeft = pramn->RAMN_stVSize - stOft; /* 计算剩余数据量 */ stNBytes = __MIN(stDataLeft, stSize); pramb = __ram_getbuf(pramn, stOft, &stStart); do { if (pramb == LW_NULL) { /* 需要填充 0 (POSIX) */ lib_bzero(pucDest, stNBytes); stRead += stNBytes; break; } else { size_t stBufSize = (__RAM_BDATASIZE - stStart); if (stBufSize >= stNBytes) { lib_memcpy(pucDest, &pramb->RAMB_ucData[stStart], stNBytes); stRead += stNBytes; break; } else { lib_memcpy(pucDest, &pramb->RAMB_ucData[stStart], stBufSize); pucDest += stBufSize; stRead += stBufSize; stNBytes -= stBufSize; stStart = 0; /* 下次拷贝从头开始 */ } } pramb = __ram_getbuf_next(pramn); } while (stNBytes); return ((ssize_t)stRead); }
/* * Transform string s2 to string s1 using the current locale so that * strcmp of transformed strings yields the same result as strcoll. * Since Bionic really does not support locales, we assume we always use * the C locale. * * This function is provided to make libstdc++-v3 usable. */ size_t lib_strxfrm(char *s1, const char *s2, size_t n) { size_t len = lib_strlen(s2) + 1; if (len < n) n = len; lib_memcpy(s1, s2, n); return len; }
/********************************************************************************************************* ** 函数名称: __procFssupRootfsRead ** 功能描述: procfs 读一个根文件系统信息 proc 文件 ** 输 入 : p_pfsn 节点控制块 ** pcBuffer 缓冲区 ** stMaxBytes 缓冲区大小 ** oft 文件指针 ** 输 出 : 实际读取的数目 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static ssize_t __procFssupStatRead (PLW_PROCFS_NODE p_pfsn, PCHAR pcBuffer, size_t stMaxBytes, off_t oft) { REGISTER PCHAR pcFileBuffer; size_t stRealSize; /* 实际的文件内容大小 */ size_t stCopeBytes; /* * 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小(创建节点时预置大小为 64 字节). */ pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn); if (pcFileBuffer == LW_NULL) { _ErrorHandle(ENOMEM); return (0); } stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn); if (stRealSize == 0) { /* 需要生成文件 */ struct statfs statfsBuf; PCHAR pcFs; if (p_pfsn->PFSN_p_pfsnoFuncs == &_G_pfsnoFssupRootfsFuncs) { pcFs = "/"; } else if (p_pfsn->PFSN_p_pfsnoFuncs == &_G_pfsnoFssupProcfsFuncs) { pcFs = "/proc"; } else { pcFs = "/"; /* 不可能运行到这里 */ } if (statfs(pcFs, &statfsBuf) < ERROR_NONE) { stRealSize = bnprintf(pcFileBuffer, __PROCFS_BUFFER_SIZE_ROOTFS, 0, "get root file system status error."); } else { stRealSize = bnprintf(pcFileBuffer, __PROCFS_BUFFER_SIZE_ROOTFS, 0, "memory used : %ld bytes\n" "total files : %ld\n", (ULONG)(statfsBuf.f_bsize * statfsBuf.f_blocks), statfsBuf.f_files); } API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize); } 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); }
/********************************************************************************************************* ** 函数名称: archDbgBpRemove ** 功能描述: 删除一个断点. ** 输 入 : ulAddr 断点地址 ** stSize 断点大小 ** pulIns 返回的之前的指令 ** bLocal 是否仅更新当前 CPU I-CACHE ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ VOID archDbgBpRemove (addr_t ulAddr, size_t stSize, ULONG ulIns, BOOL bLocal) { lib_memcpy((PCHAR)ulAddr, (PCHAR)&ulIns, stSize); #if LW_CFG_CACHE_EN > 0 if (bLocal) { API_CacheLocalTextUpdate((PVOID)ulAddr, stSize); } else { API_CacheTextUpdate((PVOID)ulAddr, stSize); } #endif /* LW_CFG_CACHE_EN > 0 */ }
/********************************************************************************************************* ** 函数名称: __tshellCharDelete ** 功能描述: shell 收到一个 del 键值. ** 输 入 : iFd 文件描述符 ** psicContext 当前输入上下文 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __tshellCharDelete (INT iFd, __PSHELL_INPUT_CTX psicContext) { if (CTX_CURSOR < CTX_TOTAL) { lib_memcpy(&CTX_BUFFER[CTX_CURSOR], &CTX_BUFFER[CTX_CURSOR + 1], CTX_TOTAL - CTX_CURSOR); CTX_BUFFER[CTX_TOTAL - 1] = ' '; write(iFd, &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR); __tshellTtyCursorMoveLeft(iFd, CTX_TOTAL - CTX_CURSOR); CTX_TOTAL--; } }
void lib_dev_set_address(struct SimDevice *dev, unsigned char buffer[6]) { /* called by ns-3 to synchronize the kernel address with */ /* the simulation address. */ struct sockaddr sa; sa.sa_family = dev->dev.type; lib_memcpy(&sa.sa_data, buffer, 6); dev->dev.netdev_ops->ndo_set_mac_address(&dev->dev, &sa); /* Note that we don't call dev_set_mac_address (&dev->dev, &sa); */ /* because this function expects to be called from within */ /* the netlink layer so, it expects to hold */ /* the netlink lock during the execution of the associated notifiers */ }
/********************************************************************************************************* ** 函数名称: __procFssupRootfsRead ** 功能描述: procfs 读一个根文件系统支持信息 proc 文件 ** 输 入 : p_pfsn 节点控制块 ** pcBuffer 缓冲区 ** stMaxBytes 缓冲区大小 ** oft 文件指针 ** 输 出 : 实际读取的数目 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static ssize_t __procFssupRead (PLW_PROCFS_NODE p_pfsn, PCHAR pcBuffer, size_t stMaxBytes, off_t oft) { REGISTER PCHAR pcFileBuffer; size_t stRealSize; /* 实际的文件内容大小 */ size_t stCopeBytes; /* * 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小(创建节点时预置大小为 64 字节). */ pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn); if (pcFileBuffer == LW_NULL) { _ErrorHandle(ENOMEM); return (0); } stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn); if (stRealSize == 0) { /* 需要生成文件 */ lib_strcpy(pcFileBuffer, "rootfs procfs ramfs romfs "); #if LW_CFG_FATFS_EN > 0 lib_strlcat(pcFileBuffer, "vfat ", __PROCFS_BUFFER_SIZE_FSSUP); #endif /* LW_CFG_FATFS_EN */ #if LW_CFG_NFS_EN > 0 lib_strlcat(pcFileBuffer, "nfs ", __PROCFS_BUFFER_SIZE_FSSUP); #endif /* LW_CFG_NFS_EN */ #if LW_CFG_YAFFS_EN > 0 lib_strlcat(pcFileBuffer, "yaffs ", __PROCFS_BUFFER_SIZE_FSSUP); #endif /* LW_CFG_YAFFS_EN */ stRealSize = lib_strlen(pcFileBuffer); API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize); } 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); }
/********************************************************************************************************* ** 函数名称: API_PciDevAdd ** 功能描述: 增加一个设备 ** 输 入 : iBus 总线号 ** iDevice 设备号 ** iFunction 功能号 ** 输 出 : 设备控制句柄 ** 全局变量: ** 调用模块: API 函数 *********************************************************************************************************/ LW_API PCI_DEV_HANDLE API_PciDevAdd (INT iBus, INT iDevice, INT iFunction) { PCI_DEV_HANDLE hDevHandle = LW_NULL; PCI_HDR phPciHdr; hDevHandle = API_PciDevHandleGet(iBus, iDevice, iFunction); if (hDevHandle != LW_NULL) { return (hDevHandle); } lib_bzero(&phPciHdr, sizeof(PCI_HDR)); API_PciGetHeader(iBus, iDevice, iFunction, &phPciHdr); switch (phPciHdr.PCIH_ucType & PCI_HEADER_TYPE_MASK) { case PCI_HEADER_TYPE_NORMAL: hDevHandle = (PCI_DEV_HANDLE)__SHEAP_ZALLOC(sizeof(PCI_DEV_TCB)); if (hDevHandle == LW_NULL) { _ErrorHandle(ERROR_SYSTEM_LOW_MEMORY); break; } hDevHandle->PDT_iDevBus = iBus; hDevHandle->PDT_iDevDevice = iDevice; hDevHandle->PDT_iDevFunction = iFunction; lib_memcpy(&hDevHandle->PDT_phDevHdr, &phPciHdr, sizeof(PCI_HDR)); __PCI_DEV_LOCK(); _List_Line_Add_Ahead(&hDevHandle->PDT_lineDevNode, &_GplinePciDevHeader); _GuiPciDevTotalNum += 1; __PCI_DEV_UNLOCK(); break; case PCI_HEADER_TYPE_BRIDGE: case PCI_HEADER_TYPE_CARDBUS: hDevHandle = LW_NULL; break; default: hDevHandle = LW_NULL; break; } return (hDevHandle); }
/********************************************************************************************************* ** 函数名称: __rtGetCallback ** 功能描述: 获取路由表接口(在 TCPIP 上下文中执行) ** 输 入 : prte 路由条目 ** flag 获取的类型掩码 ** msgbuf 缓冲表 ** num 缓冲表总数 ** piIndex 当前下标 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __rtGetCallback (PLW_RT_ENTRY prte, u_char flag, struct route_msg *msgbuf, size_t num, int *piIndex) { struct netif *pnetif = prte->RTE_pnetif; u_char ucGetFlag = 0; if (*piIndex >= num) { return; } if (prte->RTE_uiFlag & LW_RT_FLAG_U) { /* 有效路由 */ ucGetFlag |= ROUTE_RTF_UP; } if (prte->RTE_uiFlag & LW_RT_FLAG_H) { ucGetFlag |= ROUTE_RTF_HOST; /* 主机路由 */ } if (prte->RTE_uiFlag & LW_RT_FLAG_G) { ucGetFlag |= ROUTE_RTF_GATEWAY; /* 目的是一个网关的路由 */ } if ((ucGetFlag & flag) == flag) { /* 满足获取条件 */ msgbuf[*piIndex].rm_flag = ucGetFlag; msgbuf[*piIndex].rm_metric = 1; msgbuf[*piIndex].rm_dst.s_addr = prte->RTE_ipaddrDest.addr; /* 目的地址 */ if (pnetif) { msgbuf[*piIndex].rm_gw.s_addr = pnetif->gw.addr; /* 网关地址 */ msgbuf[*piIndex].rm_mask.s_addr = pnetif->netmask.addr; /* 子网掩码 */ msgbuf[*piIndex].rm_if.s_addr = pnetif->ip_addr.addr; /* 网络接口 IP */ } else { msgbuf[*piIndex].rm_gw.s_addr = IPADDR_ANY; msgbuf[*piIndex].rm_mask.s_addr = IPADDR_ANY; msgbuf[*piIndex].rm_if.s_addr = IPADDR_ANY; } lib_memcpy(msgbuf[*piIndex].rm_ifname, prte->RTE_cNetifName, IF_NAMESIZE); /* 网卡名称 */ (*piIndex)++; /* 索引向下移动 */ } }
/********************************************************************************************************* ** 函数名称: __tshellCharInster ** 功能描述: shell 收到一个普通键值. ** 输 入 : iFd 文件描述符 ** cChar 键值 ** psicContext 当前输入上下文 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __tshellCharInster (INT iFd, CHAR cChar, __PSHELL_INPUT_CTX psicContext) { if (CTX_CURSOR == CTX_TOTAL) { write(iFd, &cChar, 1); CTX_BUFFER[CTX_CURSOR] = cChar; CTX_CURSOR++; CTX_TOTAL++; } else if (CTX_CURSOR < CTX_TOTAL) { lib_memcpy(&CTX_BUFFER[CTX_CURSOR + 1], &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR); CTX_BUFFER[CTX_CURSOR] = cChar; CTX_TOTAL++; write(iFd, &CTX_BUFFER[CTX_CURSOR], CTX_TOTAL - CTX_CURSOR); CTX_CURSOR++; __tshellTtyCursorMoveLeft(iFd, CTX_TOTAL - CTX_CURSOR); } }
/********************************************************************************************************* ** 函数名称: OSFpuInitCtx ** 功能描述: 初始化一个 Fpu 上下文控制块 (这里并没有使能 FPU) ** 输 入 : pvFpuCtx FPU 上下文 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ VOID archFpuCtxInit (PVOID pvFpuCtx) { lib_memcpy(pvFpuCtx, &_G_fpuCtxInit, sizeof(LW_FPU_CONTEXT)); }
/********************************************************************************************************* ** 函数名称: _evtfdRead ** 功能描述: 读 eventfd 设备 ** 输 入 : pevtfdfil eventfd 文件 ** pcBuffer 接收缓冲区 ** stMaxBytes 接收缓冲区大小 ** 输 出 : ERROR ** 全局变量: ** 调用模块: *********************************************************************************************************/ static ssize_t _evtfdRead (PLW_EVTFD_FILE pevtfdfil, PCHAR pcBuffer, size_t stMaxBytes) { INTREG iregInterLevel; ULONG ulLwErrCode; ULONG ulTimeout; BOOL bRelease = LW_FALSE; if (!pcBuffer || (stMaxBytes < sizeof(UINT64))) { _ErrorHandle(EINVAL); return (PX_ERROR); } if (LW_CPU_GET_CUR_NESTING()) { /* 是否在中断中调用 */ _DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n"); _ErrorHandle(ERROR_KERNEL_IN_ISR); return (PX_ERROR); /* 不能在中断中调用 */ } if (pevtfdfil->EF_iFlag & O_NONBLOCK) { ulTimeout = LW_OPTION_NOT_WAIT; } else { ulTimeout = LW_OPTION_WAIT_INFINITE; } for (;;) { ulLwErrCode = API_SemaphoreBPend(pevtfdfil->EF_ulReadLock, ulTimeout); if (ulLwErrCode != ERROR_NONE) { /* 超时 */ _ErrorHandle(EAGAIN); return (0); } LW_SPIN_LOCK_QUICK(&pevtfdfil->EF_slLock, &iregInterLevel); if (pevtfdfil->EF_u64Counter) { break; } LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel); } if (pevtfdfil->EF_iFlag & EFD_SEMAPHORE) { /* EFD_SEMAPHORE */ UINT64 u64One = 1; lib_memcpy(pcBuffer, &u64One, sizeof(UINT64)); /* host bytes order */ pevtfdfil->EF_u64Counter--; } else { lib_memcpy(pcBuffer, &pevtfdfil->EF_u64Counter, sizeof(UINT64)); pevtfdfil->EF_u64Counter = 0; } if (pevtfdfil->EF_u64Counter) { bRelease = LW_TRUE; } LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel); if (bRelease) { API_SemaphoreBPost(pevtfdfil->EF_ulReadLock); SEL_WAKE_UP_ALL(&pevtfdfil->EF_selwulist, SELREAD); } API_SemaphoreBPost(pevtfdfil->EF_ulWriteLock); SEL_WAKE_UP_ALL(&pevtfdfil->EF_selwulist, SELWRITE); return (sizeof(UINT64)); }
/********************************************************************************************************* ** 函数名称: __procFsPowerInfoRead ** 功能描述: procfs 读一个 pminfo 文件 ** 输 入 : p_pfsn 节点控制块 ** pcBuffer 缓冲区 ** stMaxBytes 缓冲区大小 ** oft 文件指针 ** 输 出 : 实际读取的数目 ** 全局变量: ** 调用模块: *********************************************************************************************************/ static ssize_t __procFsPowerInfoRead (PLW_PROCFS_NODE p_pfsn, PCHAR pcBuffer, size_t stMaxBytes, off_t oft) { REGISTER PCHAR pcFileBuffer; size_t stRealSize; /* 实际的文件内容大小 */ size_t stCopeBytes; /* * 程序运行到这里, 文件缓冲一定已经分配了预置的内存大小. */ pcFileBuffer = (PCHAR)API_ProcFsNodeBuffer(p_pfsn); if (pcFileBuffer == LW_NULL) { _ErrorHandle(ENOMEM); return (0); } stRealSize = API_ProcFsNodeGetRealFileSize(p_pfsn); if (stRealSize == 0) { /* 需要生成文件 */ PCHAR pcSysMode; PCHAR pcPowerLevel; UINT uiPowerLevel; ULONG ulActive; API_PowerMCpuGet(&ulActive, &uiPowerLevel); switch (uiPowerLevel) { case LW_CPU_POWERLEVEL_TOP: pcPowerLevel = "Top"; break; case LW_CPU_POWERLEVEL_FAST: pcPowerLevel = "Fast"; break; case LW_CPU_POWERLEVEL_NORMAL: pcPowerLevel = "Normal"; break; case LW_CPU_POWERLEVEL_SLOW: pcPowerLevel = "Slow"; break; default: pcPowerLevel = "<unknown>"; break; } if (_G_bPowerSavingMode) { pcSysMode = "Power-Saving"; } else { pcSysMode = "Running"; } stRealSize = bnprintf(pcFileBuffer, __PROCFS_BUFFER_SIZE_INFO, 0, "NCPUS : %u\n" "ACTIVE : %u\n" "POWERLevel : %s\n" "SYSStatus : %s\n", (UINT)LW_NCPUS, (UINT)ulActive, pcPowerLevel, pcSysMode); API_ProcFsNodeSetRealFileSize(p_pfsn, stRealSize); } 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); }
/********************************************************************************************************* ** 函数名称: _evtfdWrite ** 功能描述: 写 eventfd 设备 ** 输 入 : pevtfdfil eventfd 文件 ** pcBuffer 将要写入的数据指针 ** stNBytes 写入数据大小 ** 输 出 : ERROR ** 全局变量: ** 调用模块: *********************************************************************************************************/ static ssize_t _evtfdWrite (PLW_EVTFD_FILE pevtfdfil, PCHAR pcBuffer, size_t stNBytes) { INTREG iregInterLevel; UINT64 u64Add; ULONG ulLwErrCode; ULONG ulTimeout; BOOL bRelease = LW_FALSE; if (!pcBuffer || (stNBytes < sizeof(UINT64))) { _ErrorHandle(EINVAL); return (PX_ERROR); } if (LW_CPU_GET_CUR_NESTING()) { /* 是否在中断中调用 */ _DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n"); _ErrorHandle(ERROR_KERNEL_IN_ISR); return (PX_ERROR); /* 不能在中断中调用 */ } lib_memcpy(&u64Add, pcBuffer, sizeof(UINT64)); if (u64Add == LW_EVENTFD_MAX_CNT) { _ErrorHandle(EINVAL); return (PX_ERROR); } if (pevtfdfil->EF_iFlag & O_NONBLOCK) { ulTimeout = LW_OPTION_NOT_WAIT; } else { ulTimeout = LW_OPTION_WAIT_INFINITE; } for (;;) { ulLwErrCode = API_SemaphoreBPend(pevtfdfil->EF_ulWriteLock, ulTimeout); if (ulLwErrCode != ERROR_NONE) { /* 超时 */ _ErrorHandle(EAGAIN); return (0); } LW_SPIN_LOCK_QUICK(&pevtfdfil->EF_slLock, &iregInterLevel); if ((LW_EVENTFD_MAX_CNT - u64Add) > pevtfdfil->EF_u64Counter) { /* 不能产生溢出 */ break; } LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel); } pevtfdfil->EF_u64Counter += u64Add; if (pevtfdfil->EF_u64Counter) { bRelease = LW_TRUE; } LW_SPIN_UNLOCK_QUICK(&pevtfdfil->EF_slLock, iregInterLevel); if (bRelease) { API_SemaphoreBPost(pevtfdfil->EF_ulReadLock); SEL_WAKE_UP_ALL(&pevtfdfil->EF_selwulist, SELREAD); } return (sizeof(UINT64)); }
/********************************************************************************************************* ** 函数名称: __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); }