/*********************************************************************************************************
** 函数名称: __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);
}
/*********************************************************************************************************
** 函数名称: _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);
}
}
/*********************************************************************************************************
** 函数名称: 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);
}
/*********************************************************************************************************
** 函数名称: __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);
}
/*********************************************************************************************************
** 函数名称: __romFsClose
** 功能描述: romfs close 操作
** 输 入 : pfdentry 文件控制块
** 输 出 : < 0 表示错误
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __romFsClose (PLW_FD_ENTRY pfdentry)
{
PLW_FD_NODE pfdnode = (PLW_FD_NODE)pfdentry->FDENTRY_pfdnode;
PROM_FILE promfile = (PROM_FILE)pfdnode->FDNODE_pvFile;
PROM_VOLUME promfs = promfile->ROMFIL_promfs;
BOOL bFree = LW_FALSE;
if (promfile) {
if (__ROMFS_VOL_LOCK(promfs) != ERROR_NONE) {
_ErrorHandle(ENXIO);
return (PX_ERROR);
}
if (API_IosFdNodeDec(&promfs->ROMFS_plineFdNodeHeader,
pfdnode) == 0) {
bFree = LW_TRUE;
}
LW_DEV_DEC_USE_COUNT(&promfs->ROMFS_devhdrHdr);
__ROMFS_VOL_UNLOCK(promfs);
if (bFree) {
__SHEAP_FREE(promfile);
}
return (ERROR_NONE);
}
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: __rtDelCallback
** 功能描述: 删除一个 sylixos 路由条目(从链表中移除, 在 TCPIP 上下文中执行)
** 输 入 : pipaddrDest 目标地址
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __rtDelCallback (ip_addr_t *pipaddrDest)
{
PLW_RT_ENTRY prte;
prte = __rtFind(pipaddrDest, 0);
if (prte) {
INT iHash = LW_RT_HASHINDEX(&prte->RTE_ipaddrDest);
if (prte->RTE_uiFlag & LW_RT_FLAG_U) {
_G_uiActiveNum--;
}
_G_uiTotalNum--;
LW_RT_CACHE_INVAL(prte);
_List_Line_Del(&prte->RTE_lineManage, &_G_plineRtHashHeader[iHash]);
__SHEAP_FREE(prte);
return (ERROR_NONE);
}
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: 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);
}
/*********************************************************************************************************
** 函数名称: pthread_key_delete
** 功能描述: 删除一个数据键. (注意, 删除函数不会调用创建时安装的析构函数)
** 输 入 : key 键
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
int pthread_key_delete (pthread_key_t key)
{
__PX_KEY_NODE *pkeyn = (__PX_KEY_NODE *)key;
if (key == 0) {
errno = EINVAL;
return (EINVAL);
}
__pthreadDataDeleteByKey(key); /* 删除所有与此 key 相关的数据 */
__PX_LOCK(); /* 锁住 posix 库 */
_List_Line_Del(&pkeyn->PKEYN_lineManage,
&_G_plineKeyHeader); /* 从 key 键链表中删除 */
__PX_UNLOCK(); /* 解锁 posix 库 */
API_SemaphoreMDelete(&pkeyn->PKEYN_ulMutex);
__resDelRawHook(&pkeyn->PKEYN_resraw);
__SHEAP_FREE(pkeyn); /* 释放 key */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_BlkRawCreate
** 功能描述: 通过 /dev/blk/xxx 块设备生成一个 BLOCK 控制块 (只能内核程序调用).
** 输 入 : pcBlkName 块设备名称
** bRdOnly 只读
** bLogic 是否为逻辑分区
** pblkraw 创建的 blk raw 控制块
** 输 出 : ERROR_NONE or PX_ERROR
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
LW_API
INT API_BlkRawCreate (CPCHAR pcBlkName, BOOL bRdOnly, BOOL bLogic, PLW_BLK_RAW pblkraw)
{
INT iFlag;
INT iRet;
if (!pcBlkName || !pblkraw) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
iFlag = (bRdOnly) ? O_RDONLY : O_RDWR;
lib_bzero(pblkraw, sizeof(LW_BLK_RAW));
pblkraw->BLKRAW_blkd.BLKD_pcName = lib_strdup(pcBlkName);
if (pblkraw == LW_NULL) {
_ErrorHandle(ENOMEM);
return (PX_ERROR);
}
__KERNEL_SPACE_ENTER();
iRet = __blkRawCreate(pblkraw, iFlag, bLogic);
__KERNEL_SPACE_EXIT();
if (iRet < ERROR_NONE) {
__SHEAP_FREE(pblkraw);
}
return (iRet);
}
/*********************************************************************************************************
** 函数名称: __pthreadDataDeleteByKey
** 功能描述: 删除指定 key 键的所有数据节点.
** 输 入 : lId 键id
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __pthreadDataDeleteByKey (long lId)
{
__PX_KEY_NODE *pkeyn = (__PX_KEY_NODE *)lId;
__PX_KEY_DATA *pkeyd;
if (pkeyn == LW_NULL) { /* 没有 key 键 */
errno = EINVAL;
return (EINVAL);
}
/*
* key 键删除, 需要遍历 key 键的私有数据表, 删除所有私有数据
*/
__PX_KEY_LOCK(pkeyn); /* 锁住 key 键 */
while (pkeyn->PKEYN_plineKeyHeader) {
pkeyd = (__PX_KEY_DATA *)pkeyn->PKEYN_plineKeyHeader; /* 链表是 KEY DATA 的第一个元素*/
_List_Line_Del(&pkeyd->PKEYD_lineManage,
&pkeyn->PKEYN_plineKeyHeader); /* 从链表中删除 */
__SHEAP_FREE(pkeyd); /* 释放线程私有数据内存 */
}
__PX_KEY_UNLOCK(pkeyn); /* 解锁 key 键 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __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_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);
}
/*********************************************************************************************************
** 函数名称: if_freenameindex
** 功能描述: free memory allocated by if_nameindex
the application shall not use the array of which ptr is the address.
** 输 入 : ptr shall be a pointer that was returned by if_nameindex().
** 输 出 : NONE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
void if_freenameindex (struct if_nameindex *ptr)
{
if (ptr) {
__SHEAP_FREE(ptr);
}
}
/*********************************************************************************************************
** 函数名称: __tshellReadlineClean
** 功能描述: shell 退出时清除 readline 信息.
** 输 入 : ulId 线程 ID
** pvRetVal 返回值
** ptcbDel 删除的 TCB
** 输 出 : 读取个数
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID __tshellReadlineClean (LW_OBJECT_HANDLE ulId, PVOID pvRetVal, PLW_CLASS_TCB ptcbDel)
{
__PSHELL_HISTORY_CTX psihc = __TTINY_SHELL_GET_HIS(ptcbDel);
__PSHELL_HISTORY psihHistory;
if (psihc) {
while (psihc->SIHC_pringHeader) {
psihHistory = _LIST_ENTRY(psihc->SIHC_pringHeader, __SHELL_HISTORY, SIH_ringManage);
_List_Ring_Del(&psihHistory->SIH_ringManage,
&psihc->SIHC_pringHeader);
__SHEAP_FREE(psihHistory);
}
__SHEAP_FREE(psihc);
__TTINY_SHELL_SET_HIS(ptcbDel, LW_NULL);
}
}
/*********************************************************************************************************
** 函数名称: __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--;
}
}
}
/*********************************************************************************************************
** 函数名称: __ram_unlink
** 功能描述: ramfs 删除一个文件
** 输 入 : pramn 文件节点
** 输 出 : 删除结果
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT __ram_unlink (PRAM_NODE pramn)
{
PRAM_VOLUME pramfs;
PRAM_NODE pramnFather;
PLW_LIST_LINE plineTemp;
if (S_ISDIR(pramn->RAMN_mode) && pramn->RAMN_plineSon) {
_ErrorHandle(ENOTEMPTY);
return (PX_ERROR);
}
pramfs = pramn->RAMN_pramfs;
pramnFather = pramn->RAMN_pramnFather;
if (pramnFather) {
_List_Line_Del(&pramn->RAMN_lineBrother,
&pramnFather->RAMN_plineSon);
} else {
_List_Line_Del(&pramn->RAMN_lineBrother,
&pramfs->RAMFS_plineSon);
}
while (pramn->RAMN_plineBStart) {
plineTemp = pramn->RAMN_plineBStart;
_List_Line_Del(plineTemp, &pramn->RAMN_plineBStart);
__RAM_BFREE(plineTemp);
pramfs->RAMFS_ulCurBlk--;
pramn->RAMN_ulCnt--;
}
if (S_ISLNK(pramn->RAMN_mode)) {
__SHEAP_FREE(pramn->RAMN_pcLink);
}
__SHEAP_FREE(pramn->RAMN_pcName);
__SHEAP_FREE(pramn);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __aioDeleteFd
** 功能描述: 从指定的 AIO_REQ_CHAIN 中删除一个 AIO_REQ_CHAIN 节点 (这里必须锁定 _G_aioqueue)
** 输 入 : paiorc AIO_REQ_CHAIN 节点
** pplineHeader 创建后加入的链表表头地址
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __aioDeleteFd (AIO_REQ_CHAIN *paiorc, LW_LIST_LINE_HEADER *pplineHeader)
{
API_SemaphoreMPend(paiorc->aiorc_mutex, LW_OPTION_WAIT_INFINITE);
__aioRemoveAllAiocb(paiorc, PX_ERROR, ECANCELED); /* 删除所有同文件描述符节点 */
API_SemaphoreMPost(paiorc->aiorc_mutex);
_List_Line_Del(&paiorc->aiorc_line, pplineHeader);
API_SemaphoreMDelete(&paiorc->aiorc_mutex);
API_ThreadCondDestroy(&paiorc->aiorc_cond);
__SHEAP_FREE(paiorc);
}
/*********************************************************************************************************
** 函数名称: 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);
}
/*********************************************************************************************************
** 函数名称: API_PipeDevDelete
** 功能描述: 删除一个管道设备
** 输 入 :
** pcName 管道名称
** bForce 强制删除
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_PipeDevDelete (PCHAR pcName, BOOL bForce)
{
REGISTER PLW_PIPE_DEV p_pipedev;
PCHAR pcTail = LW_NULL;
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)iosDevFind(pcName, &pcTail);
if ((p_pipedev == LW_NULL) || (pcName == pcTail)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "device not found.\r\n");
_ErrorHandle(ERROR_IOS_DEVICE_NOT_FOUND);
return (PX_ERROR);
}
if (bForce == LW_FALSE) {
if (LW_DEV_GET_USE_COUNT(&p_pipedev->PIPEDEV_devhdrHdr)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "too many open files.\r\n");
_ErrorHandle(EBUSY);
return (PX_ERROR);
}
if (SEL_WAKE_UP_LIST_LEN(&p_pipedev->PIPEDEV_selwulList) > 0) {
errno = EBUSY;
return (PX_ERROR);
}
}
iosDevFileAbnormal(&p_pipedev->PIPEDEV_devhdrHdr);
iosDevDelete(&p_pipedev->PIPEDEV_devhdrHdr);
SEL_WAKE_UP_LIST_TERM(&p_pipedev->PIPEDEV_selwulList);
API_SemaphoreBDelete(&p_pipedev->PIPEDEV_hWriteLock);
API_MsgQueueDelete(&p_pipedev->PIPEDEV_hMsgQueue);
__SHEAP_FREE((PVOID)p_pipedev);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_CanDevRemove
** 功能描述: 移除一个 CAN 设备
** 输 入 :
** pcName 需要移除的 CAN 设备
** bForce 模式选择
** 输 出 : ERROR_NONE or PX_ERROR
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
LW_API
INT API_CanDevRemove (PCHAR pcName, BOOL bForce)
{
__PCAN_PORT pDevHdr;
PCHAR pcTail = LW_NULL;
if (LW_CPU_GET_CUR_NESTING()) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (PX_ERROR);
}
if (_G_iCanDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
pDevHdr = (__PCAN_PORT)iosDevFind(pcName, &pcTail);
if ((pDevHdr == LW_NULL) || (pcName == pcTail)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "device not found.\r\n");
_ErrorHandle(ERROR_IOS_DEVICE_NOT_FOUND);
return (PX_ERROR);
}
if (bForce == LW_FALSE) {
if (LW_DEV_GET_USE_COUNT(&pDevHdr->CANPORT_can.CAN_devhdr)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "too many open files.\r\n");
_ErrorHandle(EBUSY);
return (PX_ERROR);
}
if (SEL_WAKE_UP_LIST_LEN(&pDevHdr->CANPORT_can.CAN_selwulList) > 0) {
errno = EBUSY;
return (PX_ERROR);
}
}
iosDevFileAbnormal(&pDevHdr->CANPORT_can.CAN_devhdr);
iosDevDelete(&pDevHdr->CANPORT_can.CAN_devhdr);
SEL_WAKE_UP_LIST_TERM(&pDevHdr->CANPORT_can.CAN_selwulList);
__canDevDelete(&pDevHdr->CANPORT_can);
__SHEAP_FREE((PVOID)pDevHdr);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: _evtfdClose
** 功能描述: 关闭 eventfd 文件
** 输 入 : pevtfdfil eventfd 文件
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT _evtfdClose (PLW_EVTFD_FILE pevtfdfil)
{
if (pevtfdfil) {
SEL_WAKE_UP_TERM(&pevtfdfil->EF_selwulist);
if (LW_DEV_GET_USE_COUNT(&_G_evtfddev.ED_devhdrHdr)) {
LW_DEV_DEC_USE_COUNT(&_G_evtfddev.ED_devhdrHdr);
}
API_SemaphoreBDelete(&pevtfdfil->EF_ulReadLock);
API_SemaphoreBDelete(&pevtfdfil->EF_ulWriteLock);
__SHEAP_FREE(pevtfdfil);
return (ERROR_NONE);
} else {
return (PX_ERROR);
}
}
/*********************************************************************************************************
** 函数名称: 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);
}
/*********************************************************************************************************
** 函数名称: __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);
}
/*********************************************************************************************************
** 函数名称: _hotplugClose
** 功能描述: 关闭热插拔消息文件
** 输 入 : photplugfil 热插拔消息文件
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT _hotplugClose (PLW_HOTPLUG_FILE photplugfil)
{
if (photplugfil) {
HOTPLUG_DEV_LOCK();
_List_Line_Del(&photplugfil->HOTPFIL_lineManage,
&_G_hotplugdev.HOTPDEV_plineFile);
HOTPLUG_DEV_UNLOCK();
_bmsgDelete(photplugfil->HOTPFIL_pbmsg);
if (LW_DEV_GET_USE_COUNT(&_G_hotplugdev.HOTPDEV_devhdrHdr)) {
LW_DEV_DEC_USE_COUNT(&_G_hotplugdev.HOTPDEV_devhdrHdr);
}
API_SemaphoreBDelete(&photplugfil->HOTPFIL_ulReadSync);
__SHEAP_FREE(photplugfil);
return (ERROR_NONE);
} else {
return (PX_ERROR);
}
}
/*********************************************************************************************************
** 函数名称: 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);
}
/*********************************************************************************************************
** 函数名称: __romFsRemove
** 功能描述: romfs remove 操作
** 输 入 : promfs 卷设备
** pcName 文件名
** 输 出 : < 0 表示错误
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __romFsRemove (PROM_VOLUME promfs,
PCHAR pcName)
{
PLW_BLK_DEV pblkd;
if (pcName == LW_NULL) {
_ErrorHandle(ERROR_IO_NO_DEVICE_NAME_IN_PATH);
return (PX_ERROR);
}
if (__STR_IS_ROOT(pcName)) {
if (__ROMFS_VOL_LOCK(promfs) != ERROR_NONE) {
_ErrorHandle(ENXIO);
return (PX_ERROR);
}
if (promfs->ROMFS_bValid == LW_FALSE) {
__ROMFS_VOL_UNLOCK(promfs);
return (ERROR_NONE); /* 正在被其他任务卸载 */
}
__re_umount_vol:
if (LW_DEV_GET_USE_COUNT((LW_DEV_HDR *)promfs)) { /* 检查是否有正在工作的文件 */
if (!promfs->ROMFS_bForceDelete) {
__ROMFS_VOL_UNLOCK(promfs);
_ErrorHandle(EBUSY);
return (PX_ERROR);
}
promfs->ROMFS_bValid = LW_FALSE;
__ROMFS_VOL_UNLOCK(promfs);
_DebugHandle(__ERRORMESSAGE_LEVEL, "disk have open file.\r\n");
iosDevFileAbnormal(&promfs->ROMFS_devhdrHdr); /* 将所有相关文件设为异常模式 */
__ROMFS_VOL_LOCK(promfs);
goto __re_umount_vol;
} else {
promfs->ROMFS_bValid = LW_FALSE;
}
pblkd = promfs->ROMFS_pblkd;
if (pblkd) {
__fsDiskLinkCounterDec(pblkd); /* 减少链接次数 */
}
iosDevDelete((LW_DEV_HDR *)promfs); /* IO 系统移除设备 */
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs->ROMFS_pcSector);
__SHEAP_FREE(promfs);
_DebugHandle(__LOGMESSAGE_LEVEL, "romfs unmount ok.\r\n");
return (ERROR_NONE);
} else {
PCHAR pcTail = LW_NULL, pcSymfile, pcPrefix;
ROMFS_DIRENT romfsdnt;
if (__ROMFS_VOL_LOCK(promfs) != ERROR_NONE) {
_ErrorHandle(ENXIO);
return (PX_ERROR);
}
if (__rfs_open(promfs, pcName, &pcTail, &pcSymfile, &romfsdnt) == ERROR_NONE) {
if (S_ISLNK(romfsdnt.ROMFSDNT_stat.st_mode)) {
if (pcTail && lib_strlen(pcTail)) { /* 连接文件有后缀 */
pcSymfile--; /* 从 / 开始 */
if (pcSymfile == pcName) {
pcPrefix = LW_NULL; /* 没有前缀 */
} else {
pcPrefix = pcName;
*pcSymfile = PX_EOS;
}
if (__rfs_path_build_link(promfs, &romfsdnt, pcName, PATH_MAX + 1,
pcPrefix, pcTail) == ERROR_NONE) {
__ROMFS_VOL_UNLOCK(promfs);
return (FOLLOW_LINK_TAIL);
}
}
}
}
__ROMFS_VOL_UNLOCK(promfs);
_ErrorHandle(EROFS);
return (PX_ERROR);
}
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: __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);
}
