/*********************************************************************************************************
** 函数名称: ls1xWatchDogDevAdd
** 功能描述: 创建 WATCH_DOG 设备
** 输 入 : pcName 设备名
** 输 出 : ERROR_CODE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT ls1xWatchDogDevAdd (CPCHAR cpcName)
{
PLS1X_WDT_DEV pwdt;
pwdt = (PLS1X_WDT_DEV)__SHEAP_ALLOC(sizeof(LS1X_WDT_DEV));
if (!pwdt) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_memset(pwdt, 0, sizeof(LS1X_WDT_DEV));
pwdt->WDT_ulPhyAddrBase = BSP_CFG_WDT_BASE;
pwdt->WDT_time = time(LW_NULL);
if (API_IosDevAddEx(&pwdt->WDT_devhdr, cpcName, _G_ils1xWDTDrvNum, DT_CHR) != ERROR_NONE) {
__SHEAP_FREE(pwdt);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
_ErrorHandle(ERROR_NONE);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __aioCreateFd
** 功能描述: 创建一个 AIO_REQ_CHAIN 节点, 并加入指定链表 (这里必须锁定 _G_aioqueue)
** 输 入 : pplineHeader 创建后加入的链表表头地址
** iFd 文件描述符
** 输 出 : 创建出的 aio req chain 节点
** 全局变量:
** 调用模块:
** 注 意 : 创建出的 AIO_REQ_CHAIN 节点, 一定是由代理线程 delete 的.
*********************************************************************************************************/
static AIO_REQ_CHAIN *__aioCreateFd (LW_LIST_LINE_HEADER *pplineHeader, int iFd)
{
AIO_REQ_CHAIN *paiorc;
paiorc = (AIO_REQ_CHAIN *)__SHEAP_ALLOC(sizeof(AIO_REQ_CHAIN));
if (paiorc == LW_NULL) {
return (LW_NULL);
}
paiorc->aiorc_mutex = API_SemaphoreMCreate("aiorc_mutex", LW_PRIO_DEF_CEILING,
LW_OPTION_DELETE_SAFE | LW_OPTION_INHERIT_PRIORITY, LW_NULL);
if (paiorc->aiorc_mutex == 0) {
__SHEAP_FREE(paiorc);
return (LW_NULL);
}
if (API_ThreadCondInit(&paiorc->aiorc_cond, LW_THREAD_PROCESS_SHARED) != ERROR_NONE) {
API_SemaphoreMDelete(&paiorc->aiorc_mutex);
__SHEAP_FREE(paiorc);
return (LW_NULL);
}
paiorc->aiorc_plineaiocb = LW_NULL;
paiorc->aiorc_fildes = iFd;
paiorc->aiorc_iscancel = 0; /* 没有被 cancel */
_List_Line_Add_Ahead(&paiorc->aiorc_line, pplineHeader);
return (paiorc);
}
/*********************************************************************************************************
** 函数名称: __ram_move
** 功能描述: ramfs 移动或者重命名一个文件
** 输 入 : pramn 文件节点
** pcNewName 新的名字
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT __ram_move (PRAM_NODE pramn, PCHAR pcNewName)
{
PRAM_VOLUME pramfs;
PRAM_NODE pramnTemp;
PRAM_NODE pramnFather;
PRAM_NODE pramnNewFather;
BOOL bRoot;
BOOL bLast;
PCHAR pcTail;
PCHAR pcTemp;
PCHAR pcFileName;
pramfs = pramn->RAMN_pramfs;
pramnFather = pramn->RAMN_pramnFather;
pramnTemp = __ram_open(pramfs, pcNewName, &pramnNewFather, &bRoot, &bLast, &pcTail);
if (pramnTemp) {
_ErrorHandle(EEXIST);
return (PX_ERROR);
}
if (bRoot || (bLast == LW_FALSE)) { /* 新名字指向根或者没有目录 */
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (pramnFather != pramnNewFather) { /* 目录发生改变 */
if (pramnFather) {
_List_Line_Del(&pramn->RAMN_lineBrother,
&pramnFather->RAMN_plineSon);
} else {
_List_Line_Del(&pramn->RAMN_lineBrother,
&pramfs->RAMFS_plineSon);
}
if (pramnNewFather) {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramnNewFather->RAMN_plineSon);
} else {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramfs->RAMFS_plineSon);
}
}
pcFileName = lib_rindex(pcNewName, PX_DIVIDER);
if (pcFileName) {
pcFileName++;
} else {
pcFileName = pcNewName;
}
pcTemp = (PCHAR)__SHEAP_ALLOC(lib_strlen(pcFileName) + 1);
if (pcTemp == LW_NULL) {
_ErrorHandle(ENOMEM);
return (PX_ERROR);
}
lib_strcpy(pcTemp, pcFileName);
__SHEAP_FREE(pramn->RAMN_pcName);
pramn->RAMN_pcName = pcTemp;
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: ls1xLedDevCreate
** 功能描述: 创建 LED 设备
** 输 入 : NONE
** pcName 设备名
** uiGpio GPIO Num
** bIsOutPutHigh 初始电平
** 输 出 : 错误号
*********************************************************************************************************/
INT ls1xLedDevCreate (CPCHAR cpcName, UINT uiGpio, BOOL bIsOutPutHigh)
{
PLS1XLED_DEV pled;
pled = (PLS1XLED_DEV)__SHEAP_ALLOC(sizeof(LS1X_LED_DEV));
if (!pled) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_memset(pled, 0, sizeof(LS1X_LED_DEV));
pled->LED_uiGpio = uiGpio;
pled->LED_bIsOutPutHigh = bIsOutPutHigh;
pled->LED_time = time(LW_NULL);
if (API_IosDevAddEx(&pled->LED_devhdr, cpcName, _G_ils1xLedDrvNum, DT_CHR) != ERROR_NONE) {
__SHEAP_FREE(pled);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
_ErrorHandle(ERROR_NONE);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: _rngCreate
** 功能描述: 建立一个 VxWorks 兼容 ring buffer 缓冲区
** 输 入 : 缓冲区大小
** 输 出 : 缓冲区控制块地址
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VX_RING_ID _rngCreate (INT iNBytes)
{
REGISTER PCHAR pcBuffer;
REGISTER VX_RING_ID vxringid;
size_t stAllocSize;
/*
* bump number of bytes requested because ring buffer algorithm
* always leaves at least one empty byte in buffer
*/
iNBytes++;
stAllocSize = (size_t)(sizeof(VX_RING) + iNBytes);
/*
* 统一分配内存避免内存碎片
*/
vxringid = (VX_RING_ID)__SHEAP_ALLOC(stAllocSize);
if (vxringid == LW_NULL) {
return (LW_NULL);
}
pcBuffer = (PCHAR)vxringid + sizeof(VX_RING);
vxringid->VXRING_iBufByteSize = iNBytes;
vxringid->VXRING_pcBuf = pcBuffer;
_rngFlush(vxringid);
return (vxringid);
}
/*********************************************************************************************************
** 函数名称: __inetPingSend
** 功能描述: 发送 ping 包
** 输 入 : iSock 套接字
** inaddr 目标 ip 地址.
** iDataSize 数据大小
** pusSeqRecv 需要判断的 seq
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __inetPingSend (INT iSock, struct in_addr inaddr, INT iDataSize, UINT16 *pusSeqRecv)
{
REGISTER size_t stPingSize = sizeof(struct icmp_echo_hdr) + iDataSize;
struct icmp_echo_hdr *icmphdrEcho;
ssize_t sstError;
struct sockaddr_in sockaddrin;
icmphdrEcho = (struct icmp_echo_hdr *)__SHEAP_ALLOC(stPingSize);
if (icmphdrEcho == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory\r\n");
return (PX_ERROR);
}
__inetPingPrepare(icmphdrEcho, iDataSize, pusSeqRecv);
sockaddrin.sin_len = sizeof(struct sockaddr_in);
sockaddrin.sin_family = AF_INET;
sockaddrin.sin_port = 0;
sockaddrin.sin_addr = inaddr;
sstError = sendto(iSock, icmphdrEcho, stPingSize, 0,
(const struct sockaddr *)&sockaddrin,
sizeof(struct sockaddr_in));
__SHEAP_FREE(icmphdrEcho);
return ((sstError > 0) ? ERR_OK : ERR_VAL);
}
/*********************************************************************************************************
** 函数名称: API_HotplugPollAdd
** 功能描述: 在 hotplug 事件处理上下文中, 加入一个循环检测函数.
** 输 入 : pfunc 函数指针
** pvArg 函数参数
** 输 出 : 操作是否成功
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_HotplugPollAdd (VOIDFUNCPTR pfunc, PVOID pvArg)
{
PLW_HOTPLUG_POLLNODE phppn;
phppn = (PLW_HOTPLUG_POLLNODE)__SHEAP_ALLOC(sizeof(LW_HOTPLUG_POLLNODE));
/* 申请控制块内存 */
if (!phppn) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY); /* 缺少内存 */
return (PX_ERROR);
}
phppn->HPPN_pfunc = pfunc;
phppn->HPPN_pvArg = pvArg;
__HOTPLUG_LOCK(); /* lock hotplug poll list */
_List_Line_Add_Ahead(&phppn->HPPN_lineManage, &_G_plineHotplugPoll);
__HOTPLUG_UNLOCK(); /* unlock hotplug poll list */
#if LW_CFG_MODULELOADER_EN > 0
if (__PROC_GET_PID_CUR() && vprocFindProc((PVOID)pfunc)) {
__resAddRawHook(&phppn->HPPN_resraw, (VOIDFUNCPTR)API_HotplugPollDelete,
(PVOID)pfunc, pvArg, 0, 0, 0, 0);
} else {
phppn->HPPN_resraw.RESRAW_bIsInstall = LW_FALSE; /* 不需要回收操作 */
}
#else
__resAddRawHook(&phppn->HPPN_resraw, (VOIDFUNCPTR)API_HotplugPollDelete,
(PVOID)pfunc, pvArg, 0, 0, 0, 0);
#endif
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __rtAddCallback
** 功能描述: 添加一个 sylixos 路由条目(加入链表, 在 TCPIP 上下文中执行)
** 输 入 : ipaddrDest 目的地址
** uiFlag flag
** pcNetifName 路由设备接口名
** 输 出 : ERROR_NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __rtAddCallback (ip_addr_t *pipaddrDest, UINT uiFlag, CPCHAR pcNetifName)
{
INT iHash = LW_RT_HASHINDEX(pipaddrDest);
PLW_RT_ENTRY prte;
prte = (PLW_RT_ENTRY)__SHEAP_ALLOC(sizeof(LW_RT_ENTRY));
if (prte == LW_NULL) {
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
prte->RTE_ipaddrDest = *pipaddrDest;
prte->RTE_pnetif = netif_find((PCHAR)pcNetifName);
prte->RTE_uiFlag = uiFlag;
lib_strlcpy(prte->RTE_cNetifName, pcNetifName, IF_NAMESIZE);
if (prte->RTE_pnetif) {
prte->RTE_uiFlag |= LW_RT_FLAG_U; /* 路由有效 */
_G_uiActiveNum++;
}
_G_uiTotalNum++;
_List_Line_Add_Ahead(&prte->RTE_lineManage, &_G_plineRtHashHeader[iHash]);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_TShellFormatAdd
** 功能描述: 为一个关键字添加格式字串信息
** 输 入 : pcKeyword 关键字
** pcFormat 格式字串
** 输 出 : 错误代码.
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_TShellFormatAdd (CPCHAR pcKeyword, CPCHAR pcFormat)
{
__PTSHELL_KEYWORD pskwNode = LW_NULL;
REGISTER size_t stStrLen;
if (__PROC_GET_PID_CUR() != 0) { /* 进程中不允许操作 */
_ErrorHandle(ENOTSUP);
return (ENOTSUP);
}
if (!pcKeyword) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "pcKeyword invalidate.\r\n");
_ErrorHandle(ERROR_TSHELL_EPARAM);
return (ERROR_TSHELL_EPARAM);
}
if (!pcFormat) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "pcHelp invalidate.\r\n");
_ErrorHandle(ERROR_TSHELL_EPARAM);
return (ERROR_TSHELL_EPARAM);
}
stStrLen = lib_strnlen(pcKeyword, LW_CFG_SHELL_MAX_KEYWORDLEN);
if (stStrLen >= (LW_CFG_SHELL_MAX_KEYWORDLEN + 1)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "pcKeyword is too long.\r\n");
_ErrorHandle(ERROR_TSHELL_EPARAM);
return (ERROR_TSHELL_EPARAM);
}
if (ERROR_NONE == __tshellKeywordFind(pcKeyword, &pskwNode)) { /* 查找关键字 */
__TTINY_SHELL_LOCK(); /* 互斥访问 */
if (pskwNode->SK_pcFormatString) {
__TTINY_SHELL_UNLOCK(); /* 释放资源 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "format string overlap.\r\n");
_ErrorHandle(ERROR_TSHELL_OVERLAP);
return (ERROR_TSHELL_OVERLAP);
}
stStrLen = lib_strlen(pcFormat); /* 为帮助字串开辟空间 */
pskwNode->SK_pcFormatString = (PCHAR)__SHEAP_ALLOC(stStrLen + 1);
if (!pskwNode->SK_pcFormatString) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (ERROR_SYSTEM_LOW_MEMORY);
}
lib_strcpy(pskwNode->SK_pcFormatString, pcFormat);
__TTINY_SHELL_UNLOCK(); /* 释放资源 */
return (ERROR_NONE);
} else {
_ErrorHandle(ERROR_TSHELL_EKEYWORD);
return (ERROR_TSHELL_EKEYWORD); /* 关键字错误 */
}
}
/*********************************************************************************************************
** 函数名称: _hotplugOpen
** 功能描述: 打开热插拔消息设备
** 输 入 : photplugdev 热插拔消息设备
** pcName 名称
** iFlags 方式
** iMode 方法
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static LONG _hotplugOpen (PLW_HOTPLUG_DEV photplugdev,
PCHAR pcName,
INT iFlags,
INT iMode)
{
PLW_HOTPLUG_FILE photplugfil;
if (pcName == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "device name invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DEVICE_NAME_IN_PATH);
return (PX_ERROR);
} else {
if (iFlags & O_CREAT) {
_ErrorHandle(ERROR_IO_FILE_EXIST); /* 不能重复创建 */
return (PX_ERROR);
}
photplugfil = (PLW_HOTPLUG_FILE)__SHEAP_ALLOC(sizeof(LW_HOTPLUG_FILE));
if (!photplugfil) {
__nomem:
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
photplugfil->HOTPFIL_iFlag = iFlags;
photplugfil->HOTPFIL_iMsg = LW_HOTPLUG_MSG_ALL;
photplugfil->HOTPFIL_pbmsg = _bmsgCreate(LW_CFG_HOTPLUG_DEV_DEFAULT_BUFSIZE);
if (photplugfil->HOTPFIL_pbmsg == LW_NULL) {
__SHEAP_FREE(photplugfil);
goto __nomem;
}
photplugfil->HOTPFIL_ulReadSync = API_SemaphoreBCreate("hotplug_rsync", LW_FALSE,
LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (photplugfil->HOTPFIL_ulReadSync == LW_OBJECT_HANDLE_INVALID) {
_bmsgDelete(photplugfil->HOTPFIL_pbmsg);
__SHEAP_FREE(photplugfil);
return (PX_ERROR);
}
HOTPLUG_DEV_LOCK();
_List_Line_Add_Tail(&photplugfil->HOTPFIL_lineManage,
&_G_hotplugdev.HOTPDEV_plineFile);
HOTPLUG_DEV_UNLOCK();
LW_DEV_INC_USE_COUNT(&_G_hotplugdev.HOTPDEV_devhdrHdr);
return ((LONG)photplugfil);
}
}
/*********************************************************************************************************
** 函数名称: _evtfdOpen
** 功能描述: 打开 eventfd 设备
** 输 入 : pevtfddev eventfd 设备
** pcName 名称
** iFlags 方式
** iMode 方法
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static LONG _evtfdOpen (PLW_EVTFD_DEV pevtfddev,
PCHAR pcName,
INT iFlags,
INT iMode)
{
PLW_EVTFD_FILE pevtfdfil;
if (pcName == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "device name invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DEVICE_NAME_IN_PATH);
return (PX_ERROR);
} else {
if (iFlags & O_CREAT) {
_ErrorHandle(ERROR_IO_FILE_EXIST);
return (PX_ERROR);
}
pevtfdfil = (PLW_EVTFD_FILE)__SHEAP_ALLOC(sizeof(LW_EVTFD_FILE));
if (!pevtfdfil) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
pevtfdfil->EF_iFlag = iFlags;
pevtfdfil->EF_ulReadLock = API_SemaphoreBCreate("evtfd_rlock", LW_FALSE,
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
if (pevtfdfil->EF_ulReadLock == LW_OBJECT_HANDLE_INVALID) {
__SHEAP_FREE(pevtfdfil);
return (PX_ERROR);
}
pevtfdfil->EF_ulWriteLock = API_SemaphoreBCreate("evtfd_wlock", LW_TRUE,
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
if (pevtfdfil->EF_ulWriteLock == LW_OBJECT_HANDLE_INVALID) {
API_SemaphoreBDelete(&pevtfdfil->EF_ulReadLock);
__SHEAP_FREE(pevtfdfil);
return (PX_ERROR);
}
pevtfdfil->EF_u64Counter = 0ull;
lib_bzero(&pevtfdfil->EF_selwulist, sizeof(LW_SEL_WAKEUPLIST));
pevtfdfil->EF_selwulist.SELWUL_hListLock = _G_hEvtfdSelMutex;
LW_SPIN_INIT(&pevtfdfil->EF_slLock);
LW_DEV_INC_USE_COUNT(&_G_evtfddev.ED_devhdrHdr);
return ((LONG)pevtfdfil);
}
}
/*********************************************************************************************************
** 函数名称: __tshellTtyInputHistorySave
** 功能描述: shell 记录一条输入.
** 输 入 : psicContext 输入上下文
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __tshellHistorySave (__PSHELL_INPUT_CTX psicContext)
{
PLW_CLASS_TCB ptcbCur;
__PSHELL_HISTORY_CTX psihc;
__PSHELL_HISTORY psihHistory;
PLW_LIST_RING pring;
LW_TCB_GET_CUR_SAFE(ptcbCur);
psihc = __TTINY_SHELL_GET_HIS(ptcbCur);
pring = psihc->SIHC_pringHeader;
while (pring) { /* 循环查找是否与以前的相同 */
psihHistory = _LIST_ENTRY(pring, __SHELL_HISTORY, SIH_ringManage);
if (lib_strcmp(psihHistory->SIH_cInputSave, CTX_BUFFER) == 0) { /* 如果相同 */
if (pring == psihc->SIHC_pringHeader) {
return; /* 如果是表头, 则不需要处理 */
} else {
_List_Ring_Del(&psihHistory->SIH_ringManage,
&psihc->SIHC_pringHeader);
_List_Ring_Add_Ahead(&psihHistory->SIH_ringManage,
&psihc->SIHC_pringHeader); /* 放在表头位置 */
return;
}
}
pring = _list_ring_get_next(pring);
if (pring == psihc->SIHC_pringHeader) {
break;
}
}
psihHistory = (__PSHELL_HISTORY)__SHEAP_ALLOC(sizeof(__SHELL_HISTORY) +
lib_strlen(CTX_BUFFER));
if (psihHistory) {
lib_strcpy(psihHistory->SIH_cInputSave, CTX_BUFFER);
_List_Ring_Add_Ahead(&psihHistory->SIH_ringManage,
&psihc->SIHC_pringHeader); /* 加入新的输入 */
psihc->SIHC_uiCounter++;
if (psihc->SIHC_uiCounter > __INPUT_SAVE_MAX) { /* 需要删除最老的一条 */
PLW_LIST_RING pringPrev = _list_ring_get_prev(psihc->SIHC_pringHeader);
psihHistory = _LIST_ENTRY(pringPrev, __SHELL_HISTORY, SIH_ringManage);
_List_Ring_Del(&psihHistory->SIH_ringManage,
&psihc->SIHC_pringHeader);
__SHEAP_FREE(psihHistory);
psihc->SIHC_uiCounter--;
}
}
}
/*********************************************************************************************************
** 函数名称: __canInitQueue
** 功能描述: 缓冲初始化
** 输 入 : uiMaxFrame 缓冲区 can 帧个数
** 输 出 : 缓冲区指针
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static __PCAN_QUEUE __canInitQueue (UINT uiMaxFrame)
{
size_t stAllocSize;
__CAN_QUEUE *pcanq = NULL;
stAllocSize = (size_t)(sizeof(__CAN_QUEUE) + (uiMaxFrame * sizeof(CAN_FRAME)));
pcanq = (__CAN_QUEUE *)__SHEAP_ALLOC(stAllocSize);
if (pcanq == LW_NULL) {
return (LW_NULL);
}
pcanq->CANQ_uiCounter = 0;
pcanq->CANQ_uiMaxFrame = uiMaxFrame;
pcanq->CANQ_pcanframeBuffer = (PCAN_FRAME)(pcanq + 1);
pcanq->CANQ_pcanframeIn = pcanq->CANQ_pcanframeBuffer;
pcanq->CANQ_pcanframeOut = pcanq->CANQ_pcanframeBuffer;
pcanq->CANQ_pcanframeEnd = pcanq->CANQ_pcanframeBuffer + pcanq->CANQ_uiMaxFrame;
return (pcanq);
}
/*********************************************************************************************************
** 函数名称: pthread_key_create
** 功能描述: 创建一个数据键.
** 输 入 : pkey 键 (返回)
** destructor 删除函数
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
** 注 意 : key 信号量设置为 LW_OPTION_OBJECT_GLOBAL 是因为 key 已经使用了原始资源进行回收.
API 函数
*********************************************************************************************************/
LW_API
int pthread_key_create (pthread_key_t *pkey, void (*destructor)(void *))
{
__PX_KEY_NODE *pkeyn;
if (pkey == LW_NULL) {
errno = EINVAL;
return (EINVAL);
}
API_ThreadOnce(&_G_bKeyDelHookAdd, __pthreadKeyOnce); /* 安装线程删除回调 */
pkeyn = (__PX_KEY_NODE *)__SHEAP_ALLOC(sizeof(__PX_KEY_NODE)); /* 创建节点内存 */
if (pkeyn == LW_NULL) {
errno = ENOMEM;
return (ENOMEM);
}
pkeyn->PKEYN_lId = (long)pkeyn;
pkeyn->PKEYN_pfuncDestructor = destructor;
pkeyn->PKEYN_plineKeyHeader = LW_NULL;
pkeyn->PKEYN_ulMutex = API_SemaphoreMCreate("pxkey", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_DELETE_SAFE |
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
if (pkeyn->PKEYN_ulMutex == LW_OBJECT_HANDLE_INVALID) {
__SHEAP_FREE(pkeyn);
errno = ENOSPC;
return (ENOSPC);
}
__PX_LOCK(); /* 锁住 posix 库 */
_List_Line_Add_Ahead(&pkeyn->PKEYN_lineManage,
&_G_plineKeyHeader); /* 加入 key 键链表 */
__PX_UNLOCK(); /* 解锁 posix 库 */
__resAddRawHook(&pkeyn->PKEYN_resraw, (VOIDFUNCPTR)pthread_key_delete,
pkeyn, 0, 0, 0, 0, 0); /* 加入资源管理器 */
*pkey = (pthread_key_t)pkeyn; /* 将内存地址定义为 id */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __tshellAodvs
** 功能描述: 系统命令 "aodvs"
** 输 入 : iArgC 参数个数
** ppcArgV 参数表
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __tshellAodvs (INT iArgC, PCHAR *ppcArgV)
{
PCHAR pcBuffer;
size_t stSize;
size_t stOffset;
UINT uiNumEntries;
uiNumEntries = (UINT)__rtSafeRun((FUNCPTR)__rtEntryMaxNum, 0, 0, 0, 0, 0, 0);
if (uiNumEntries == 0) {
printf("no route entry.\n");
return (ERROR_NONE);
}
/*
* 在 net safe 状态下不允许调用 printf 等使用 IO 的语句. 所以只能打印到缓冲区中,
* 然后统一使用 IO 打印.
*/
stSize = LW_RT_PRINT_SIZE * uiNumEntries;
pcBuffer = (PCHAR)__SHEAP_ALLOC(stSize);
if (pcBuffer == LW_NULL) {
fprintf(stderr, "system low memory.\n");
return (PX_ERROR);
}
/*
* 打印 aodv route entry
*/
stOffset = 0;
printf("aodv routing tables\n");
printf("Destination Gateway Mask Flag Hops Interface\n");
__rtSafeRun((FUNCPTR)aodv_rt_traversal, (void *)__aodvEntryPrint,
pcBuffer, (PVOID)stSize, &stOffset, 0, 0);
if (stOffset > 0) {
fwrite(pcBuffer, stOffset, 1, stdout);
fflush(stdout); /* 这里必须确保输出完成 */
}
__SHEAP_FREE(pcBuffer);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __tshellReadlineInit
** 功能描述: shell 初始化 readline.
** 输 入 : NONE
** 输 出 : 初始化是否成功
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __tshellReadlineInit (VOID)
{
PLW_CLASS_TCB ptcbCur;
__PSHELL_HISTORY_CTX psihc;
LW_TCB_GET_CUR_SAFE(ptcbCur);
psihc = __TTINY_SHELL_GET_HIS(ptcbCur);
if (psihc == LW_NULL) {
psihc = (__PSHELL_HISTORY_CTX)__SHEAP_ALLOC(sizeof(__SHELL_HISTORY_CTX));
if (psihc == LW_NULL) {
fprintf(stderr, "read line tool no memory!\n");
return (PX_ERROR);
}
lib_bzero(psihc, sizeof(__SHELL_HISTORY_CTX));
__TTINY_SHELL_SET_HIS(ptcbCur, psihc);
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __inetPing6Send
** 功能描述: 发送 ping 包
** 输 入 : iSock 套接字
** pin6addr 目标 ip 地址.
** iDataSize 数据大小
** pcNetif 网络接口名 (NULL 表示自动确定接口)
** pusSeqRecv 需要判断的 seq
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __inetPing6Send (INT iSock,
struct in6_addr *pin6addr,
INT iDataSize,
CPCHAR pcNetif,
UINT16 *pusSeqRecv)
{
REGISTER size_t stPingSize = sizeof(struct icmp6_echo_hdr) + iDataSize;
struct icmp6_echo_hdr *icmp6hdrEcho;
ssize_t sstError;
struct sockaddr_in6 sockaddrin6;
struct ip6_addr ip6addrDest;
icmp6hdrEcho = (struct icmp6_echo_hdr *)__SHEAP_ALLOC(stPingSize);
if (icmp6hdrEcho == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory\r\n");
return (PX_ERROR);
}
ip6addrDest.addr[0] = pin6addr->un.u32_addr[0];
ip6addrDest.addr[1] = pin6addr->un.u32_addr[1];
ip6addrDest.addr[2] = pin6addr->un.u32_addr[2];
ip6addrDest.addr[3] = pin6addr->un.u32_addr[3];
if (__inetPing6Prepare(icmp6hdrEcho, &ip6addrDest, iDataSize, pcNetif, pusSeqRecv) < ERROR_NONE) {
return (ERR_VAL);
}
sockaddrin6.sin6_len = sizeof(struct sockaddr_in);
sockaddrin6.sin6_family = AF_INET6;
sockaddrin6.sin6_port = 0;
sockaddrin6.sin6_addr = *pin6addr;
sstError = sendto(iSock, icmp6hdrEcho, stPingSize, 0,
(const struct sockaddr *)&sockaddrin6,
sizeof(struct sockaddr_in6));
__SHEAP_FREE(icmp6hdrEcho);
return ((sstError > 0) ? ERR_OK : ERR_VAL);
}
/*********************************************************************************************************
** 函数名称: if_nameindex
** 功能描述: return all network interface names and indexes
** 输 入 : NONE
** 输 出 : An array of structures identifying local interfaces
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
struct if_nameindex *if_nameindex (void)
{
struct netif *pnetif;
int iNum = 1; /* 需要一个空闲的位置 */
struct if_nameindex *pifnameindexArry;
LWIP_NETIF_LOCK(); /* 进入临界区 */
for(pnetif = netif_list; pnetif != LW_NULL; pnetif = pnetif->next) {
iNum++;
}
pifnameindexArry = (struct if_nameindex *)__SHEAP_ALLOC(sizeof(struct if_nameindex) * (size_t)iNum);
if (pifnameindexArry) {
int i = 0;
for(pnetif = netif_list;
pnetif != LW_NULL;
pnetif = pnetif->next) {
pifnameindexArry[i].if_index = (unsigned)pnetif->num;
pifnameindexArry[i].if_name_buf[0] = pnetif->name[0];
pifnameindexArry[i].if_name_buf[1] = pnetif->name[1];
pifnameindexArry[i].if_name_buf[2] = (char)(pnetif->num + '0');
pifnameindexArry[i].if_name_buf[3] = PX_EOS;
pifnameindexArry[i].if_name = pifnameindexArry[i].if_name_buf;
i++;
}
pifnameindexArry[i].if_index = 0;
pifnameindexArry[i].if_name_buf[0] = PX_EOS;
pifnameindexArry[i].if_name = pifnameindexArry[i].if_name_buf;
} else {
errno = ENOMEM;
}
LWIP_NETIF_UNLOCK(); /* 退出临界区 */
return (pifnameindexArry);
}
/*********************************************************************************************************
** 函数名称: readlink
** 功能描述: 读取符号链接文件的.
** 输 入 : pcSymPath 链接文件
** pcLinkDst 连接内容缓冲
** stMaxSize 缓冲大小
** 输 出 : 读取的内容长度
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ssize_t readlink (CPCHAR pcSymPath, PCHAR pcLinkDst, size_t stMaxSize)
{
REGISTER LONG lValue;
PLW_FD_ENTRY pfdentry;
PLW_DEV_HDR pdevhdrHdr;
CHAR cFullFileName[MAX_FILENAME_LENGTH];
PCHAR pcLastTimeName;
INT iLinkCount = 0;
ssize_t sstRet;
PCHAR pcName = (PCHAR)pcSymPath;
if (pcName == LW_NULL) { /* 检查文件名 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "name invalidate.\r\n");
_ErrorHandle(EFAULT); /* Bad address */
return (PX_ERROR);
}
if (pcName[0] == PX_EOS) {
_ErrorHandle(ENOENT);
return (PX_ERROR);
}
if (lib_strcmp(pcName, ".") == 0) { /* 滤掉当前目录 */
pcName++;
}
if (ioFullFileNameGet(pcName, &pdevhdrHdr, cFullFileName) != ERROR_NONE) {
_ErrorHandle(ENOENT);
return (PX_ERROR);
}
pcLastTimeName = (PCHAR)__SHEAP_ALLOC(MAX_FILENAME_LENGTH);
if (pcLastTimeName == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_strlcpy(pcLastTimeName, cFullFileName, MAX_FILENAME_LENGTH);
pfdentry = _IosFileNew(pdevhdrHdr, cFullFileName); /* 创建一个临时的 fd_entry */
if (pfdentry == LW_NULL) {
__SHEAP_FREE(pcLastTimeName);
return (PX_ERROR);
}
for (;;) {
lValue = iosOpen(pdevhdrHdr, cFullFileName, O_RDONLY, 0);
if (lValue != FOLLOW_LINK_TAIL) { /* FOLLOW_LINK_FILE 直接退出 */
break;
} else {
if (iLinkCount++ > _S_iIoMaxLinkLevels) { /* 链接文件层数太多 */
_IosFileDelete(pfdentry);
__SHEAP_FREE(pcLastTimeName);
_ErrorHandle(ELOOP);
return (PX_ERROR);
}
}
/*
* 驱动程序如果返回 FOLLOW_LINK_????, cFullFileName内部一定是目标的绝对地址, 即以/起始的文件名.
*/
if (ioFullFileNameGet(cFullFileName, &pdevhdrHdr, cFullFileName) != ERROR_NONE) {
_IosFileDelete(pfdentry);
__SHEAP_FREE(pcLastTimeName);
_ErrorHandle(EXDEV);
return (PX_ERROR);
}
lib_strlcpy(pcLastTimeName, cFullFileName, MAX_FILENAME_LENGTH);
}
if ((lValue != PX_ERROR) && (lValue != FOLLOW_LINK_FILE)) {
_IosFileSet(pfdentry, pdevhdrHdr, lValue, O_RDONLY);
_IosFileClose(pfdentry); /* 关闭 */
}
_IosFileDelete(pfdentry); /* 删除临时的 fd_entry */
sstRet = iosReadlink(pdevhdrHdr, pcLastTimeName, pcLinkDst, stMaxSize);
__SHEAP_FREE(pcLastTimeName);
return (sstRet);
}
/*********************************************************************************************************
** 函数名称: __romFsOpen
** 功能描述: 打开或者创建文件
** 输 入 : promfs romfs 文件系统
** pcName 文件名
** iFlags 方式
** iMode mode_t
** 输 出 : < 0 错误
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static LONG __romFsOpen (PROM_VOLUME promfs,
PCHAR pcName,
INT iFlags,
INT iMode)
{
INT iError;
PROM_FILE promfile;
PLW_FD_NODE pfdnode;
size_t stSize;
BOOL bIsNew;
struct stat *pstat;
INT iFollowLinkType;
PCHAR pcTail, pcSymfile, pcPrefix;
if (pcName == LW_NULL) { /* 无文件名 */
_ErrorHandle(ERROR_IO_NO_DEVICE_NAME_IN_PATH);
return (PX_ERROR);
} else {
stSize = sizeof(ROM_FILE) + lib_strlen(pcName);
promfile = (PROM_FILE)__SHEAP_ALLOC(stSize);
if (promfile == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_bzero(promfile, stSize);
lib_strcpy(promfile->ROMFIL_cName, pcName); /* 记录文件名 */
promfile->ROMFIL_promfs = promfs;
if (__ROMFS_VOL_LOCK(promfs) != ERROR_NONE) {
_ErrorHandle(ENXIO);
return (PX_ERROR);
}
if (__STR_IS_ROOT(promfile->ROMFIL_cName)) {
promfile->ROMFIL_iFileType = __ROMFS_FILE_TYPE_DEV;
goto __file_open_ok; /* 设备打开正常 */
}
if (promfs->ROMFS_bValid == LW_FALSE) {
__ROMFS_VOL_UNLOCK(promfs);
__SHEAP_FREE(promfile);
_ErrorHandle(ERROR_IOS_DEVICE_NOT_FOUND);
return (PX_ERROR);
}
iError = __rfs_open(promfs, pcName, &pcTail, &pcSymfile, &promfile->ROMFIL_romfsdnt);
if (iError) {
__ROMFS_VOL_UNLOCK(promfs);
__SHEAP_FREE(promfile);
if (iFlags & O_CREAT) {
_ErrorHandle(EROFS); /* 只读文件系统 */
}
return (PX_ERROR);
}
/*
* 首先处理符号链接文件情况
*/
if (S_ISLNK(promfile->ROMFIL_romfsdnt.ROMFSDNT_stat.st_mode)) {
pcSymfile--; /* 从 / 开始 */
if (pcSymfile == pcName) {
pcPrefix = LW_NULL; /* 没有前缀 */
} else {
pcPrefix = pcName;
*pcSymfile = PX_EOS;
}
if (pcTail && lib_strlen(pcTail)) {
iFollowLinkType = FOLLOW_LINK_TAIL; /* 连接目标内部文件 */
} else {
iFollowLinkType = FOLLOW_LINK_FILE; /* 链接文件本身 */
}
if (__rfs_path_build_link(promfs, &promfile->ROMFIL_romfsdnt, pcName, PATH_MAX + 1,
pcPrefix, pcTail) == ERROR_NONE) {
/* 构造链接目标 */
__ROMFS_VOL_UNLOCK(promfs);
__SHEAP_FREE(promfile);
return (iFollowLinkType);
} else { /* 构造连接失败 */
__ROMFS_VOL_UNLOCK(promfs);
__SHEAP_FREE(promfile);
return (PX_ERROR);
}
} else if (S_ISDIR(promfile->ROMFIL_romfsdnt.ROMFSDNT_stat.st_mode)) {
promfile->ROMFIL_iFileType = __ROMFS_FILE_TYPE_DIR;
} else {
promfile->ROMFIL_iFileType = __ROMFS_FILE_TYPE_NODE;
}
__file_open_ok:
pstat = &promfile->ROMFIL_romfsdnt.ROMFSDNT_stat;
pfdnode = API_IosFdNodeAdd(&promfs->ROMFS_plineFdNodeHeader,
pstat->st_dev,
(ino64_t)pstat->st_ino,
iFlags,
iMode,
pstat->st_uid,
pstat->st_gid,
pstat->st_size,
(PVOID)promfile,
&bIsNew); /* 添加文件节点 */
if (pfdnode == LW_NULL) { /* 无法创建 fd_node 节点 */
__ROMFS_VOL_UNLOCK(promfs);
__SHEAP_FREE(promfile);
return (PX_ERROR);
}
LW_DEV_INC_USE_COUNT(&promfs->ROMFS_devhdrHdr); /* 更新计数器 */
__ROMFS_VOL_UNLOCK(promfs);
if (bIsNew == LW_FALSE) { /* 有重复打开 */
__SHEAP_FREE(promfile);
}
return ((LONG)pfdnode); /* 返回文件节点 */
}
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: API_RomFsDevCreate
** 功能描述: 创建 romfs 文件系统设备.
** 输 入 : pcName 设备名(设备挂接的节点地址)
** pblkd romfs 物理设备.
** 输 出 : < 0 表示失败
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_RomFsDevCreate (PCHAR pcName, PLW_BLK_DEV pblkd)
{
PROM_VOLUME promfs;
if (_G_iRomfsDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "romfs Driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
if ((pblkd == LW_NULL) || (pblkd->BLKD_pcName == LW_NULL)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "block device invalidate.\r\n");
_ErrorHandle(ERROR_IOS_DEVICE_NOT_FOUND);
return (PX_ERROR);
}
if ((pcName == LW_NULL) || __STR_IS_ROOT(pcName)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "mount name invalidate.\r\n");
_ErrorHandle(EFAULT); /* Bad address */
return (PX_ERROR);
}
promfs = (PROM_VOLUME)__SHEAP_ALLOC(sizeof(ROM_VOLUME));
if (promfs == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_bzero(promfs, sizeof(ROM_VOLUME)); /* 清空卷控制块 */
promfs->ROMFS_bValid = LW_TRUE;
promfs->ROMFS_hVolLock = API_SemaphoreMCreate("romvol_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_WAIT_FIFO | LW_OPTION_DELETE_SAFE |
LW_OPTION_INHERIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (!promfs->ROMFS_hVolLock) { /* 无法创建卷锁 */
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
promfs->ROMFS_pblkd = pblkd; /* 记录物理设备 */
promfs->ROMFS_ulSectorSize = pblkd->BLKD_ulBytesPerSector;
if (promfs->ROMFS_ulSectorSize == 0) {
if (pblkd->BLKD_pfuncBlkIoctl(pblkd,
LW_BLKD_GET_SECSIZE,
&promfs->ROMFS_ulSectorSize) < ERROR_NONE) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
}
promfs->ROMFS_ulSectorNum = pblkd->BLKD_ulNSector;
if (promfs->ROMFS_ulSectorNum == 0) {
if (pblkd->BLKD_pfuncBlkIoctl(pblkd,
LW_BLKD_GET_SECNUM,
&promfs->ROMFS_ulSectorNum) < ERROR_NONE) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
}
promfs->ROMFS_pcSector = (PCHAR)__SHEAP_ALLOC((size_t)promfs->ROMFS_ulSectorSize);
if (promfs->ROMFS_pcSector == LW_NULL) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
promfs->ROMFS_ulCurSector = (ULONG)-1; /* 当前窗口无效 */
if (__rfs_mount(promfs)) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs->ROMFS_pcSector);
__SHEAP_FREE(promfs);
_DebugHandle(__ERRORMESSAGE_LEVEL, "format unknown.\r\n");
_ErrorHandle(ERROR_IO_VOLUME_ERROR);
return (PX_ERROR);
}
promfs->ROMFS_uid = getuid();
promfs->ROMFS_gid = getgid();
lib_time(&promfs->ROMFS_time); /* 获得当前时间 */
if (iosDevAddEx(&promfs->ROMFS_devhdrHdr, pcName, _G_iRomfsDrvNum, DT_DIR)
!= ERROR_NONE) { /* 安装文件系统设备 */
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs->ROMFS_pcSector);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
__fsDiskLinkCounterAdd(pblkd); /* 增加块设备链接 */
_DebugFormat(__LOGMESSAGE_LEVEL, "target \"%s\" mount ok.\r\n", pcName);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_OemDiskMountEx2
** 功能描述: 自动挂载一个磁盘的所有分区. 可以使用指定的文件系统类型挂载
** 输 入 : pcVolName 根节点名字 (当前 API 将根据分区情况在末尾加入数字)
** pblkdDisk 物理磁盘控制块 (必须是直接操作物理磁盘)
** pvDiskCacheMem 磁盘 CACHE 缓冲区的内存起始地址 (为零表示动态分配磁盘缓冲)
** stMemSize 磁盘 CACHE 缓冲区大小 (为零表示不需要 DISK CACHE)
** iMaxRBurstSector 磁盘猝发读的最大扇区数
** iMaxWBurstSector 磁盘猝发写的最大扇区数
** pcFsName 文件系统类型, 例如: "vfat" "tpsfs" "iso9660" "ntfs" ...
** bForceFsType 是否强制使用指定的文件系统类型
** 输 出 : OEM 磁盘控制块
** 全局变量:
** 调用模块:
** 注 意 : 挂载的文件系统不包含 yaffs 文件系统, yaffs 属于静态文件系统.
API 函数
*********************************************************************************************************/
LW_API
PLW_OEMDISK_CB API_OemDiskMountEx2 (CPCHAR pcVolName,
PLW_BLK_DEV pblkdDisk,
PVOID pvDiskCacheMem,
size_t stMemSize,
INT iMaxRBurstSector,
INT iMaxWBurstSector,
CPCHAR pcFsName,
BOOL bForceFsType)
{
INT i;
INT iErrLevel = 0;
REGISTER ULONG ulError;
CHAR cFullVolName[MAX_FILENAME_LENGTH]; /* 完整卷标名 */
INT iBlkIo;
INT iBlkIoErr;
PCHAR pcTail;
INT iVolSeq;
REGISTER INT iNPart;
DISKPART_TABLE dptPart; /* 分区表 */
PLW_OEMDISK_CB poemd;
FUNCPTR pfuncFsCreate;
/*
* 挂载节点名检查
*/
if (pcVolName == LW_NULL || *pcVolName != PX_ROOT) { /* 名字错误 */
_ErrorHandle(EINVAL);
return (LW_NULL);
}
i = (INT)lib_strnlen(pcVolName, (PATH_MAX - __OEM_DISK_TAIL_LEN));
if (i >= (PATH_MAX - __OEM_DISK_TAIL_LEN)) { /* 名字过长 */
_ErrorHandle(ERROR_IO_NAME_TOO_LONG);
return (LW_NULL);
}
/*
* 分配 OEM 磁盘控制块内存
*/
poemd = (PLW_OEMDISK_CB)__SHEAP_ALLOC(sizeof(LW_OEMDISK_CB) + (size_t)i);
if (poemd == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (LW_NULL);
}
lib_bzero(poemd, sizeof(LW_OEMDISK_CB) + i); /* 清空 */
poemd->OEMDISK_pblkdDisk = pblkdDisk;
/*
* 分配磁盘缓冲内存
*/
if ((pvDiskCacheMem == LW_NULL) && (stMemSize > 0)) { /* 是否需要动态分配磁盘缓冲 */
poemd->OEMDISK_pvCache = __SHEAP_ALLOC(stMemSize);
if (poemd->OEMDISK_pvCache == LW_NULL) {
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY); /* 系统缺少内存 */
goto __error_handle;
}
pvDiskCacheMem = poemd->OEMDISK_pvCache;
}
/*
* 创建物理磁盘缓冲, 同时会初始化磁盘
*/
if (stMemSize) {
ulError = API_DiskCacheCreateEx(pblkdDisk,
pvDiskCacheMem,
stMemSize,
iMaxRBurstSector,
iMaxWBurstSector,
&poemd->OEMDISK_pblkdCache);
if (ulError) {
iErrLevel = 1;
goto __error_handle;
}
} else {
poemd->OEMDISK_pblkdCache = pblkdDisk; /* 不需要磁盘缓冲 */
}
/*
* 创建 blk io 设备
*/
pcTail = lib_rindex(pcVolName, PX_DIVIDER);
if (pcTail == LW_NULL) {
pcTail = (PCHAR)pcVolName;
} else {
pcTail++;
}
for (iBlkIo = 0; iBlkIo < 64; iBlkIo++) {
snprintf(cFullVolName, MAX_FILENAME_LENGTH, "%s%s%d", LW_BLKIO_PERFIX, pcTail, iBlkIo);
if (API_IosDevMatchFull(cFullVolName) == LW_NULL) {
iBlkIoErr = API_OemBlkIoCreate(cFullVolName,
poemd->OEMDISK_pblkdCache);
if (iBlkIoErr == ERROR_NONE) {
break;
} else if (errno != ERROR_IOS_DUPLICATE_DEVICE_NAME) {
iErrLevel = 2;
goto __error_handle;
}
}
}
/*
* 扫面磁盘所有分区信息
*/
iNPart = API_DiskPartitionScan(poemd->OEMDISK_pblkdCache,
&dptPart); /* 扫描分区表 */
if (iNPart < 1) {
iErrLevel = 3;
goto __error_handle;
}
poemd->OEMDISK_uiNPart = (UINT)iNPart; /* 记录分区数量 */
/*
* 初始化所有的分区挂载失败
*/
for (i = 0; i < iNPart; i++) {
poemd->OEMDISK_iVolSeq[i] = PX_ERROR; /* 默认为挂载失败 */
}
/*
* 分别挂载各个分区
*/
iVolSeq = 0;
for (i = 0; i < iNPart; i++) { /* 装载各个分区 */
if (API_DiskPartitionGet(&dptPart, i,
&poemd->OEMDISK_pblkdPart[i]) < 0) { /* 获得分区 logic device */
break;
}
__refined_seq:
sprintf(cFullVolName, "%s%d", pcVolName, iVolSeq); /* 获得完整卷名 */
if (API_IosDevMatchFull(cFullVolName)) { /* 设备名重名预判 */
iVolSeq++;
goto __refined_seq; /* 重新确定卷序号 */
}
pfuncFsCreate = LW_NULL;
switch (dptPart.DPT_dpoLogic[i].DPO_dpnEntry.DPN_ucPartType) { /* 判断文件系统分区类型 */
case LW_DISK_PART_TYPE_FAT12: /* FAT 文件系统类型 */
case LW_DISK_PART_TYPE_FAT16:
case LW_DISK_PART_TYPE_FAT16_BIG:
case LW_DISK_PART_TYPE_WIN95_FAT32:
case LW_DISK_PART_TYPE_WIN95_FAT32LBA:
case LW_DISK_PART_TYPE_WIN95_FAT16LBA:
if (bForceFsType) { /* 是否强制指定文件系统类型 */
pfuncFsCreate = __fsCreateFuncGet(pcFsName);
} else {
pfuncFsCreate = __fsCreateFuncGet("vfat");
}
break;
case LW_DISK_PART_TYPE_TPS:
if (bForceFsType) { /* 是否强制指定文件系统类型 */
pfuncFsCreate = __fsCreateFuncGet(pcFsName);
} else {
pfuncFsCreate = __fsCreateFuncGet("tpsfs");
}
break;
default: /* 默认使用指定文件系统类型 */
if (bForceFsType) { /* 是否强制指定文件系统类型 */
pfuncFsCreate = __fsCreateFuncGet(pcFsName);
}
break;
}
if (pfuncFsCreate) { /* 存在支持的文件系统 */
if (pfuncFsCreate(cFullVolName,
poemd->OEMDISK_pblkdPart[i]) < 0) { /* 挂载文件系统 */
if (API_GetLastError() == ERROR_IOS_DUPLICATE_DEVICE_NAME) {
iVolSeq++;
goto __refined_seq; /* 重新确定卷序号 */
} else {
goto __mount_over; /* 挂载失败 */
}
}
poemd->OEMDISK_pdevhdr[i] = API_IosDevMatchFull(cFullVolName);
poemd->OEMDISK_iVolSeq[i] = iVolSeq; /* 记录卷序号 */
} else {
continue; /* 此分区无法加载 */
}
if (poemd->OEMDISK_iVolSeq[i] >= 0) {
__oemDiskForceDeleteEn(cFullVolName); /* 默认为强制删除 */
}
iVolSeq++; /* 已处理完当前卷 */
}
__mount_over: /* 所有分区挂载完毕 */
lib_strcpy(poemd->OEMDISK_cVolName, pcVolName); /* 拷贝名字 */
return (poemd);
__error_handle:
if (iErrLevel > 2) {
if (poemd->OEMDISK_pblkdCache) {
API_OemBlkIoDelete(poemd->OEMDISK_pblkdCache);
}
}
if (iErrLevel > 1) {
if (poemd->OEMDISK_pblkdCache != pblkdDisk) {
API_DiskCacheDelete(poemd->OEMDISK_pblkdCache);
}
}
if (iErrLevel > 0) {
if (poemd->OEMDISK_pvCache) {
__SHEAP_FREE(poemd->OEMDISK_pvCache);
}
}
__SHEAP_FREE(poemd);
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);
}
/*********************************************************************************************************
** 函数名称: API_PipeDevCreate
** 功能描述: 创建一个管道设备
** 输 入 :
** pcName 管道名称
** ulNMessages 管道中消息数量
** stNBytes 每一条消息的最大字节数
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_PipeDevCreate (PCHAR pcName,
ULONG ulNMessages,
size_t stNBytes)
{
REGISTER PLW_PIPE_DEV p_pipedev;
if (LW_CPU_GET_CUR_NESTING()) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (PX_ERROR);
}
if (_G_iPipeDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
p_pipedev = (PLW_PIPE_DEV)__SHEAP_ALLOC(sizeof(LW_PIPE_DEV));
if (p_pipedev == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_bzero(p_pipedev, sizeof(LW_PIPE_DEV));
p_pipedev->PIPEDEV_iAbortFlag = 0;
p_pipedev->PIPEDEV_ulRTimeout = LW_OPTION_WAIT_INFINITE; /* 初始化为永久等待 */
p_pipedev->PIPEDEV_ulWTimeout = LW_OPTION_WAIT_INFINITE; /* 初始化为永久等待 */
p_pipedev->PIPEDEV_hWriteLock = API_SemaphoreBCreate("pipe_wsync",
LW_TRUE,
_G_ulPipeLockOpt | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (!p_pipedev->PIPEDEV_hWriteLock) {
__SHEAP_FREE((PVOID)p_pipedev);
return (PX_ERROR);
}
p_pipedev->PIPEDEV_hMsgQueue = API_MsgQueueCreate("pipe_msg",
ulNMessages, stNBytes,
_G_ulPipeLockOpt | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (!p_pipedev->PIPEDEV_hMsgQueue) {
API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
__SHEAP_FREE((PVOID)p_pipedev);
return (PX_ERROR);
}
SEL_WAKE_UP_LIST_INIT(&p_pipedev->PIPEDEV_selwulList);
if (iosDevAddEx(&p_pipedev->PIPEDEV_devhdrHdr, pcName, _G_iPipeDrvNum, DT_FIFO) != ERROR_NONE) {
API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
API_MsgQueueDelete(&p_pipedev->PIPEDEV_hMsgQueue);
SEL_WAKE_UP_LIST_TERM(&p_pipedev->PIPEDEV_selwulList);
__SHEAP_FREE((PVOID)p_pipedev);
_DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
p_pipedev->PIPEDEV_timeCreate = lib_time(LW_NULL);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_CanDevCreate
** 功能描述: 创建 can 设备
** 输 入 : pcName 设备名
** pcanchan 通道
** uiRdFrameSize 接收缓冲区大小
** uiWrtFrameSize 发送缓冲区大小
** 输 出 : 是否成功
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
LW_API
INT API_CanDevCreate (PCHAR pcName,
CAN_CHAN *pcanchan,
UINT uiRdFrameSize,
UINT uiWrtFrameSize)
{
__PCAN_PORT pcanport;
INT iTemp;
if ((!pcName) || (!pcanchan)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "parameter error.\r\n");
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if ((uiRdFrameSize < 1) || (uiWrtFrameSize < 1)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "parameter error.\r\n");
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if ((!pcanchan->pDrvFuncs->callbackInstall) ||
(!pcanchan->pDrvFuncs->txStartup)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "parameter error.\r\n");
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
if (_G_iCanDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "can Driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
pcanport = (__PCAN_PORT)__SHEAP_ALLOC(sizeof(__CAN_PORT));
if (!pcanport) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_bzero(pcanport, sizeof(__CAN_PORT));
iTemp = __canDevInit(&pcanport->CANPORT_can,
uiRdFrameSize,
uiWrtFrameSize); /* 初始化设备控制块 */
if (iTemp != ERROR_NONE) {
__SHEAP_FREE(pcanport);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
__canFlushRd(pcanport);
__canFlushWrt(pcanport);
pcanport->CANPORT_pcanchan = pcanchan;
pcanchan->pDrvFuncs->callbackInstall(pcanchan, CAN_CALLBACK_GET_TX_DATA,
(CAN_CALLBACK)__canITx, (PVOID)pcanport);
pcanchan->pDrvFuncs->callbackInstall(pcanchan, CAN_CALLBACK_PUT_RCV_DATA,
(CAN_CALLBACK)__canIRx, (PVOID)pcanport);
pcanchan->pDrvFuncs->callbackInstall(pcanchan, CAN_CALLBACK_PUT_BUS_STATE,
(CAN_CALLBACK)__canSetBusState, (PVOID)pcanport);
iTemp = (INT)iosDevAddEx(&pcanport->CANPORT_can.CAN_devhdr,
pcName,
_G_iCanDrvNum,
DT_CHR);
if (iTemp) {
__canDevDelete(&pcanport->CANPORT_can);
__SHEAP_FREE(pcanport);
_DebugHandle(__ERRORMESSAGE_LEVEL, "add device error.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
} else {
return (ERROR_NONE);
}
}
/*********************************************************************************************************
** 函数名称: __untarFile
** 功能描述: unpackage a .tar file.
** 输 入 : pcTarFile tar file
** pcDestPath destination directory
** 输 出 : 0 or -1
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __untarFile (CPCHAR pcTarFile, CPCHAR pcDestPath)
{
INT iFdTar;
char *pcBuf;
ssize_t sstN;
char cFname[100];
char cLinkname[100];
int iSum;
int iHdrChksum;
int iRetVal;
unsigned long ulI;
unsigned long ulNblocks;
unsigned long ulSize;
unsigned char ucLinkflag;
ULONG ulTotalFile = 0ul;
ULONG ulTotalDir = 0ul;
iFdTar = open(pcTarFile, O_RDONLY);
if (iFdTar < 0) {
fprintf(stderr, "can not open : %s : %s\n", pcTarFile, lib_strerror(errno));
return (PX_ERROR);
}
pcBuf = (char *)__SHEAP_ALLOC(512);
if (pcBuf == LW_NULL) {
close(iFdTar);
fprintf(stderr, "system low memory.\n");
return (PX_ERROR);
}
iRetVal = ERROR_NONE;
while (1) {
char cOutFile[PATH_MAX + 1];
mode_t mode;
if ((sstN = read(iFdTar, pcBuf, 512)) != 512) {
break;
}
if (lib_strncmp(&pcBuf[257], TMAGIC, 5)) {
break;
}
lib_strlcpy(cFname, pcBuf, 100);
ucLinkflag = pcBuf[156];
ulSize = __untarOctal2Long(&pcBuf[124], 12);
iHdrChksum = (int)__untarOctal2Long(&pcBuf[148], 8);
iSum = __untarHeaderChksum(pcBuf);
if (iSum != iHdrChksum) {
fprintf(stderr, "tar file : %s chksum error.\n", pcTarFile);
iRetVal = PX_ERROR;
break;
}
mode = (int)__untarOctal2Long(&pcBuf[100], 8);
if (pcDestPath) {
if (lib_strcmp(pcDestPath, PX_STR_ROOT) == 0) {
if (cFname[0] == PX_ROOT) {
lib_strlcpy(cOutFile, cFname, PATH_MAX + 1);
} else {
snprintf(cOutFile, PATH_MAX + 1, "%s%s", pcDestPath, cFname);
}
} else {
snprintf(cOutFile, PATH_MAX + 1, "%s/%s", pcDestPath, cFname);
}
} else {
lib_strlcpy(cOutFile, cFname, PATH_MAX + 1);
}
if (ucLinkflag == SYMTYPE) {
printf("unpackage %s <LNK> ...\n", cOutFile);
lib_strlcpy(cLinkname, &pcBuf[157], 100);
symlink(cLinkname, cOutFile);
ulTotalFile++;
} else if (ucLinkflag == REGTYPE) {
INT iFdOut;
printf("unpackage %s size : %ld ...\n", cOutFile, ulSize);
ulNblocks = (((ulSize) + 511) & ~511) / 512;
if ((iFdOut = creat(cOutFile, mode)) < 0) {
fprintf(stderr, "can not create : %s\n", cOutFile);
lseek(iFdTar, (off_t)(ulNblocks * 512), SEEK_CUR);
} else {
for (ulI = 0; ulI < ulNblocks; ulI++) {
sstN = read(iFdTar, pcBuf, 512);
sstN = min(sstN, ulSize - (ulI * 512));
write(iFdOut, pcBuf, (size_t)sstN);
}
close(iFdOut);
ulTotalFile++;
}
} else if (ucLinkflag == DIRTYPE) {
printf("unpackage %s <DIR> ...\n", cOutFile);
mkdir(cOutFile, mode);
ulTotalDir++;
}
}
__SHEAP_FREE(pcBuf);
close(iFdTar);
printf("unpackage total %lu files %lu directory.\n", ulTotalFile, ulTotalDir);
return (iRetVal);
}
/*********************************************************************************************************
** 函数名称: API_DiskRiad0Create
** 功能描述: 创建一个 RAID-0 类型磁盘阵列块设备
** 输 入 : pblkd[] 物理块设备列表
** uiNDisks 物理磁盘数量 必须为 2, 4 块这两种选择其中之一
** stStripe 磁盘条带字节数, 必须是扇区字节数的 2 的指数倍, 最少为 32KB
** 例如 64K, 128K 等
** ppblkDiskRaid 返回的 RAID 虚拟磁盘
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_DiskRiad0Create (PLW_BLK_DEV pblkd[],
UINT uiNDisks,
size_t stStripe,
PLW_BLK_DEV *ppblkDiskRaid)
{
INT i;
PLW_DISKRAID0_CB pdiskr = LW_NULL;
ULONG ulBytesPerSector;
ULONG ulBytesPerBlock;
ULONG ulTotalSector;
if (!pblkd || !ppblkDiskRaid ||
((uiNDisks != 2) && (uiNDisks != 4)) ||
(stStripe < (32 * LW_CFG_KB_SIZE)) ||
(stStripe & (stStripe - 1))) {
_ErrorHandle(EINVAL);
return (EINVAL);
}
pdiskr = (PLW_DISKRAID0_CB)__SHEAP_ALLOC(sizeof(LW_DISKRAID0_CB));
if (pdiskr == LW_NULL) {
goto __handle_errror;
}
pdiskr->DISKR_ppblkdDisk = (PLW_BLK_DEV *)__SHEAP_ALLOC(sizeof(PLW_BLK_DEV) * uiNDisks);
if (pdiskr->DISKR_ppblkdDisk == LW_NULL) {
goto __handle_errror;
}
for (i = 0; i < uiNDisks; i++) {
pdiskr->DISKR_ppblkdDisk[i] = pblkd[i];
if (pblkd[i] == LW_NULL) {
goto __handle_errror;
}
}
pdiskr->DISKR_uiNDisks = uiNDisks;
if (uiNDisks == 2) {
pdiskr->DISKR_uiDiskShift = 1;
pdiskr->DISKR_uiDiskMask = 0x01;
} else {
pdiskr->DISKR_uiDiskShift = 2;
pdiskr->DISKR_uiDiskMask = 0x03;
}
if (__diskRaidCheck(pblkd, uiNDisks,
&ulBytesPerSector,
&ulBytesPerBlock,
&ulTotalSector)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "RAID-0 system block disk not EQU.\r\n");
_ErrorHandle(ENOTSUP);
return (ENOTSUP);
}
for (i = 0; i < 16; i++) {
if (stStripe == (ulBytesPerSector << i)) {
break;
}
}
if (i >= 16) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "RAID-0 system stripe size error.\r\n");
_ErrorHandle(ENOTSUP);
return (ENOTSUP);
}
pdiskr->DISKR_uiStripeShift = i;
pdiskr->DISKR_uiStripeMask = (1 << i) - 1;
pdiskr->DISKR_blkdRaid.BLKD_pcName = "RAID-0";
pdiskr->DISKR_blkdRaid.BLKD_pfuncBlkRd = __raid0DevRd;
pdiskr->DISKR_blkdRaid.BLKD_pfuncBlkWrt = __raid0DevWrt;
pdiskr->DISKR_blkdRaid.BLKD_pfuncBlkIoctl = __raid0DevIoctl;
pdiskr->DISKR_blkdRaid.BLKD_pfuncBlkReset = __raid0DevReset;
pdiskr->DISKR_blkdRaid.BLKD_pfuncBlkStatusChk = __raid0DevStatusChk;
pdiskr->DISKR_blkdRaid.BLKD_ulNSector = ulTotalSector * uiNDisks;
pdiskr->DISKR_blkdRaid.BLKD_ulBytesPerSector = ulBytesPerSector;
pdiskr->DISKR_blkdRaid.BLKD_ulBytesPerBlock = ulBytesPerBlock;
pdiskr->DISKR_blkdRaid.BLKD_bRemovable = pblkd[0]->BLKD_bRemovable;
pdiskr->DISKR_blkdRaid.BLKD_bDiskChange = LW_FALSE;
pdiskr->DISKR_blkdRaid.BLKD_iRetry = pblkd[0]->BLKD_iRetry;
pdiskr->DISKR_blkdRaid.BLKD_iFlag = pblkd[0]->BLKD_iFlag;
pdiskr->DISKR_blkdRaid.BLKD_iLogic = LW_FALSE;
pdiskr->DISKR_blkdRaid.BLKD_uiLinkCounter = 0;
pdiskr->DISKR_blkdRaid.BLKD_pvLink = LW_NULL;
pdiskr->DISKR_blkdRaid.BLKD_uiPowerCounter = 0;
pdiskr->DISKR_blkdRaid.BLKD_uiInitCounter = 0;
*ppblkDiskRaid = (PLW_BLK_DEV)pdiskr;
_DebugHandle(__LOGMESSAGE_LEVEL, "RAID-0 system has been create.\r\n");
return (ERROR_NONE);
__handle_errror:
if (pdiskr) {
__SHEAP_FREE(pdiskr);
}
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (ERROR_SYSTEM_LOW_MEMORY);
}
/*********************************************************************************************************
** 函数名称: __ram_maken
** 功能描述: ramfs 创建一个文件
** 输 入 : pramfs 文件系统
** pcName 文件名
** pramnFather 父亲, NULL 表示根目录
** mode mode_t
** pcLink 如果为连接文件, 这里指明连接目标.
** 输 出 : 创建结果
** 全局变量:
** 调用模块:
*********************************************************************************************************/
PRAM_NODE __ram_maken (PRAM_VOLUME pramfs,
CPCHAR pcName,
PRAM_NODE pramnFather,
mode_t mode,
CPCHAR pcLink)
{
PRAM_NODE pramn = (PRAM_NODE)__SHEAP_ALLOC(sizeof(RAM_NODE));
CPCHAR pcFileName;
if (pramn == LW_NULL) {
_ErrorHandle(ENOMEM);
return (LW_NULL);
}
lib_bzero(pramn, sizeof(RAM_NODE));
pcFileName = lib_rindex(pcName, PX_DIVIDER);
if (pcFileName) {
pcFileName++;
} else {
pcFileName = pcName;
}
pramn->RAMN_pcName = (PCHAR)__SHEAP_ALLOC(lib_strlen(pcFileName) + 1);
if (pramn->RAMN_pcName == LW_NULL) {
__SHEAP_FREE(pramn);
_ErrorHandle(ENOMEM);
return (LW_NULL);
}
lib_strcpy(pramn->RAMN_pcName, pcFileName);
if (S_ISLNK(mode)) {
pramn->RAMN_pcLink = (PCHAR)__SHEAP_ALLOC(lib_strlen(pcLink) + 1);
if (pramn->RAMN_pcLink == LW_NULL) {
__SHEAP_FREE(pramn->RAMN_pcName);
__SHEAP_FREE(pramn);
_ErrorHandle(ENOMEM);
return (LW_NULL);
}
lib_strcpy(pramn->RAMN_pcLink, pcLink);
} else {
if ((mode & S_IFMT) == 0) {
mode |= S_IFREG;
}
pramn->RAMN_pcLink = LW_NULL;
}
pramn->RAMN_pramnFather = pramnFather;
pramn->RAMN_pramfs = pramfs;
pramn->RAMN_mode = mode;
pramn->RAMN_timeCreate = lib_time(LW_NULL);
pramn->RAMN_timeAccess = pramn->RAMN_timeCreate;
pramn->RAMN_timeChange = pramn->RAMN_timeCreate;
pramn->RAMN_uid = getuid();
pramn->RAMN_gid = getgid();
pramn->RAMN_prambCookie = LW_NULL;
if (pramnFather) {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramnFather->RAMN_plineSon);
} else {
_List_Line_Add_Ahead(&pramn->RAMN_lineBrother,
&pramfs->RAMFS_plineSon);
}
return (pramn);
}
/*********************************************************************************************************
** 函数名称: __tshellRoute
** 功能描述: 系统命令 "route"
** 输 入 : iArgC 参数个数
** ppcArgV 参数表
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT __tshellRoute (INT iArgC, PCHAR *ppcArgV)
{
#define LW_RT_PRINT_SIZE 74
INT iError;
FUNCPTR pfuncAddOrChange;
PCHAR pcOpAddorChange;
UINT uiFlag = 0;
ip_addr_t ipaddr;
CHAR cNetifName[IF_NAMESIZE];
if (iArgC == 1) {
PCHAR pcBuffer;
size_t stSize;
size_t stOffset;
UINT uiNumEntries;
uiNumEntries = (UINT)__rtSafeRun((FUNCPTR)__rtEntryMaxNum, 0, 0, 0, 0, 0, 0);
if (uiNumEntries == 0) {
printf("no route entry.\n");
return (ERROR_NONE);
}
/*
* 在 net safe 状态下不允许调用 printf 等使用 IO 的语句. 所以只能打印到缓冲区中,
* 然后统一使用 IO 打印.
*/
stSize = LW_RT_PRINT_SIZE * uiNumEntries;
pcBuffer = (PCHAR)__SHEAP_ALLOC(stSize);
if (pcBuffer == LW_NULL) {
fprintf(stderr, "system low memory.\n");
return (PX_ERROR);
}
/*
* 打印 kernel route entry
*/
stOffset = 0;
printf("kernel routing tables\n");
printf("Destination Gateway Mask Flag Interface\n");
__rtSafeRun((FUNCPTR)__rtTraversal, (void *)__rtEntryPrint,
pcBuffer, (PVOID)stSize, &stOffset, 0, 0);
if (stOffset > 0) {
fwrite(pcBuffer, stOffset, 1, stdout);
fflush(stdout); /* 这里必须确保输出完成 */
}
/*
* 打印 lwip build-in route entry
*/
stOffset = 0;
printf("\nbuild-in routing tables\n");
printf("Destination Gateway Mask Flag Interface\n");
__rtSafeRun((FUNCPTR)__buildinRtPrint,
pcBuffer, (PVOID)stSize, &stOffset, 0, 0, 0);
if (stOffset > 0) {
fwrite(pcBuffer, stOffset, 1, stdout);
fflush(stdout); /* 这里必须确保输出完成 */
}
__SHEAP_FREE(pcBuffer);
return (ERROR_NONE);
} else { /* 操作路由表 */
if (lib_strcmp(ppcArgV[1], "add") == 0) {
pfuncAddOrChange = __rtAdd;
pcOpAddorChange = "add";
} else if (lib_strcmp(ppcArgV[1], "change") == 0) {
pfuncAddOrChange = __rtChange;
pcOpAddorChange = "change";
} else {
pfuncAddOrChange = LW_NULL;
}
if (pfuncAddOrChange && (iArgC == 6)) { /* 添加或者修改路由表 */
if (!ipaddr_aton(ppcArgV[3], &ipaddr)) {
fprintf(stderr, "inet address format error.\n");
goto __error_handle;
}
if (lib_strcmp(ppcArgV[4], "if") == 0) { /* 使用 ifindex 查询网卡 */
INT iIndex = lib_atoi(ppcArgV[5]);
if (if_indextoname(iIndex, cNetifName) == LW_NULL) {
fprintf(stderr, "can not find net interface with ifindex %d.\n", iIndex);
goto __error_handle;
}
} else if (lib_strcmp(ppcArgV[4], "dev") == 0) {
lib_strlcpy(cNetifName, ppcArgV[5], IF_NAMESIZE);
} else {
fprintf(stderr, "net interface argument error.\n");
goto __error_handle;
}
if (lib_strcmp(ppcArgV[2], "-host") == 0) { /* 主机路由 */
uiFlag |= LW_RT_FLAG_H;
} else if (lib_strcmp(ppcArgV[2], "-gw") == 0) { /* 设置网卡网关 */
uiFlag |= LW_RT_GW_FLAG_SET;
pfuncAddOrChange = __rtSetGw;
} else if (lib_strcmp(ppcArgV[2], "-net") != 0) { /* 非网络路由 */
fprintf(stderr, "route add must determine -host or -net.\n");
goto __error_handle;
}
iError = pfuncAddOrChange(&ipaddr, uiFlag, cNetifName); /* 操作路由表 */
if (iError >= 0) {
printf("route %s %s successful.\n", ppcArgV[3], pcOpAddorChange);
return (ERROR_NONE);
}
} else if (pfuncAddOrChange && (iArgC == 5)) { /* 设置默认网关 */
if (lib_strcmp(ppcArgV[2], "default") != 0) {
goto __error_handle;
}
if (lib_strcmp(ppcArgV[3], "if") == 0) { /* 使用 ifindex 查询网卡 */
INT iIndex = lib_atoi(ppcArgV[4]);
if (if_indextoname(iIndex, cNetifName) == LW_NULL) {
fprintf(stderr, "can not find net interface with ifindex %d.\n", iIndex);
goto __error_handle;
}
} else if (lib_strcmp(ppcArgV[3], "dev") == 0) {
lib_strlcpy(cNetifName, ppcArgV[4], IF_NAMESIZE);
} else {
fprintf(stderr, "net interface argument error.\n");
goto __error_handle;
}
uiFlag |= LW_RT_GW_FLAG_DEFAULT;
pfuncAddOrChange = __rtSetGw;
iError = pfuncAddOrChange(&ipaddr, uiFlag, cNetifName); /* 设置默认路由出口 */
if (iError >= 0) {
printf("default device set successful.\n");
return (ERROR_NONE);
}
} else if ((lib_strcmp(ppcArgV[1], "del") == 0) && iArgC == 3) {/* 删除一个路由表项 */
if (!ipaddr_aton(ppcArgV[2], &ipaddr)) {
fprintf(stderr, "inet address format error.\n");
goto __error_handle;
}
iError = __rtDel(&ipaddr);
if (iError >= 0) {
printf("route %s delete successful.\n", ppcArgV[2]);
return (ERROR_NONE);
}
}
}
__error_handle:
fprintf(stderr, "argments error!\n");
return (-ERROR_TSHELL_EPARAM);
}
