/*********************************************************************************************************
** 函数名称: _resInit
** 功能描述: 资源管理器初始化 (此初始化放在内核初始化完毕后, 内核的一些基本资源这里不需要记录)
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID _resInit (VOID)
{
__resReclaimInit(); /* 资源回收器初始化 */
_G_ulResHLock = API_SemaphoreMCreate("resh_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY | LW_OPTION_DELETE_SAFE |
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
_G_ulResRawLock = API_SemaphoreMCreate("resraw_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY | LW_OPTION_DELETE_SAFE |
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
API_SystemHookAdd(__resAddHandleHook, LW_OPTION_OBJECT_CREATE_HOOK);
API_SystemHookAdd(__resDelHandleHook, LW_OPTION_OBJECT_DELETE_HOOK);
}
/*********************************************************************************************************
** 函数名称: __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);
}
/*********************************************************************************************************
** 函数名称: _hotplugDevCreate
** 功能描述: 安装 hotplug 消息设备
** 输 入 : NONE
** 输 出 : 设备是否创建成功
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
INT _hotplugDevCreate (VOID)
{
if (_G_iHotplugDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
_G_hotplugdev.HOTPDEV_plineFile = LW_NULL;
_G_hotplugdev.HOTPDEV_ulMutex = API_SemaphoreMCreate("hotplug_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_DELETE_SAFE |
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (_G_hotplugdev.HOTPDEV_ulMutex == LW_OBJECT_HANDLE_INVALID) {
return (PX_ERROR);
}
SEL_WAKE_UP_LIST_INIT(&_G_hotplugdev.HOTPDEV_selwulList);
if (iosDevAddEx(&_G_hotplugdev.HOTPDEV_devhdrHdr, LW_HOTPLUG_DEV_PATH,
_G_iHotplugDrvNum, DT_CHR) != ERROR_NONE) {
API_SemaphoreMDelete(&_G_hotplugdev.HOTPDEV_ulMutex);
SEL_WAKE_UP_LIST_TERM(&_G_hotplugdev.HOTPDEV_selwulList);
return (PX_ERROR);
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: _posixPRWLockInit
** 功能描述: 初始化 读写锁 环境.
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID _posixPRWLockInit (VOID)
{
_G_ulPRWLockInitLock = API_SemaphoreMCreate("prwinit", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_WAIT_PRIORITY |
LW_OPTION_DELETE_SAFE, LW_NULL);
}
/*********************************************************************************************************
** 函数名称: API_PciDevInit
** 功能描述: PCI 设备管理初始化
** 输 入 : NONE
** 输 出 : ERROR or OK
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
LW_API
INT API_PciDevInit (VOID)
{
_GuiPciDevTotalNum = 0;
_GulPciDevLock = LW_OBJECT_HANDLE_INVALID;
_GplinePciDevHeader = LW_NULL;
_GulPciDevLock = API_SemaphoreMCreate("pci_dev_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_DELETE_SAFE |
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
if (_GulPciDevLock == LW_OBJECT_HANDLE_INVALID) {
return (PX_ERROR);
}
API_TShellKeywordAdd("pcidev", __tshellPciDevCmd);
API_TShellFormatAdd("pcidev", " [add | del] [[all] | 1:0.1]");
API_TShellHelpAdd("pcidev", "show, add, del pci device table\n"
"eg. pcidev\n"
" pcidev add all\n"
" pcidev add 1:0.1\n"
" pcidev del 1:0.1\n");
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_EventfdDrvInstall
** 功能描述: 安装 eventfd 设备驱动程序
** 输 入 : NONE
** 输 出 : 驱动是否安装成功
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_EventfdDrvInstall (VOID)
{
if (_G_iEvtfdDrvNum <= 0) {
_G_iEvtfdDrvNum = iosDrvInstall(LW_NULL,
LW_NULL,
_evtfdOpen,
_evtfdClose,
_evtfdRead,
_evtfdWrite,
_evtfdIoctl);
DRIVER_LICENSE(_G_iEvtfdDrvNum, "Dual BSD/GPL->Ver 1.0");
DRIVER_AUTHOR(_G_iEvtfdDrvNum, "Han.hui");
DRIVER_DESCRIPTION(_G_iEvtfdDrvNum, "eventfd driver.");
}
if (_G_hEvtfdSelMutex == LW_OBJECT_HANDLE_INVALID) {
_G_hEvtfdSelMutex = API_SemaphoreMCreate("evtfdsel_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_WAIT_PRIORITY | LW_OPTION_DELETE_SAFE |
LW_OPTION_INHERIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
}
return ((_G_iEvtfdDrvNum == (PX_ERROR)) ? (PX_ERROR) : (ERROR_NONE));
}
/*********************************************************************************************************
** 函数名称: API_TShellInit
** 功能描述: 安装 tshell 程序, 相当于初始化 tshell 平台
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
VOID API_TShellInit (VOID)
{
if (_G_hTShellLock == 0) {
_G_hTShellLock = API_SemaphoreMCreate("tshell_lock", LW_PRIO_DEF_CEILING,
__TTINY_SHELL_LOCK_OPT, LW_NULL); /* 创建锁 */
if (!_G_hTShellLock) {
_DebugHandle(__ERRORMESSAGE_LEVEL,
"tshell lock can not create.\r\n");
_DebugHandle(__LOGMESSAGE_LEVEL,
"ttniy shell system is not initialize.\r\n");
return;
}
API_SystemHookAdd(__tShellOptDeleteHook,
LW_OPTION_THREAD_DELETE_HOOK); /* 安装回调函数 */
API_SystemHookAdd(__tshellReadlineClean,
LW_OPTION_THREAD_DELETE_HOOK); /* readline 历史删除 */
__tshellColorInit(); /* 初始化 shell 颜色系统 */
}
if (_G_bIsInstallSysCmd == LW_FALSE) {
_G_bIsInstallSysCmd = LW_TRUE;
__tshellSysVarInit(); /* 初始化系统环境变量 */
__tshellUserCmdInit(); /* 初始化用户管理命令 */
__tshellSysCmdInit(); /* 初始化系统命令 */
#if LW_CFG_SHELL_HEAP_TRACE_EN > 0
__tshellHeapCmdInit(); /* 初始化内存堆命令 */
#endif /* LW_CFG_SHELL_HEAP_TRACE_EN */
__tshellFsCmdInit(); /* 初始化文件系统命令 */
__tshellModemCmdInit(); /* 初始化 modem 命令 */
__tshellTarCmdInit(); /* 初始化 tar 命令 */
}
}
/*********************************************************************************************************
** 函数名称: netif_add_hook
** 功能描述: 创建网络接口回调函数, 返回网络接口号 (网络上下文中调用)
** 输 入 : pvNetif 网络接口
** 输 出 : ERR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT netif_add_hook (PVOID pvNetif)
{
struct netif *netif = (struct netif *)pvNetif;
INT i;
if (_G_ulNetifLock == 0) {
_G_ulNetifLock = API_SemaphoreMCreate("netif_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_DELETE_SAFE |
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
}
LWIP_NETIF_LOCK(); /* 进入临界区 */
for (i = 0; i < __LW_NETIF_MAX_NUM; i++) {
if (_G_pnetifArray[i] == LW_NULL) {
_G_pnetifArray[i] = netif;
netif->num = (UINT8)i;
_G_uiNetifNum++;
break;
}
}
LWIP_NETIF_UNLOCK(); /* 退出临界区 */
if (i < __LW_NETIF_MAX_NUM) {
rt_netif_add_hook(netif); /* 更新路由表有效标志 */
return (ERR_OK);
} else {
return (ERR_USE);
}
}
/*********************************************************************************************************
** 函数名称: _hotplugInit
** 功能描述: 初始化 hotplug 库
** 输 入 : NONE
** 输 出 : 是否初始化成功
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT _hotplugInit (VOID)
{
LW_OBJECT_HANDLE hHotplugThread;
LW_CLASS_THREADATTR threadattr;
if (_jobQueueInit(&_G_jobqHotplug, &_G_jobmsgHotplug[0],
LW_CFG_HOTPLUG_MAX_MSGS, LW_FALSE)) {
return (PX_ERROR);
}
_G_hHotplugLock = API_SemaphoreMCreate("hotplug_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_DELETE_SAFE |
LW_OPTION_WAIT_FIFO | LW_OPTION_OBJECT_GLOBAL,
LW_NULL); /* 建立 poll 链操作锁 */
if (!_G_hHotplugLock) {
_jobQueueFinit(&_G_jobqHotplug);
return (PX_ERROR);
}
API_ThreadAttrBuild(&threadattr, LW_CFG_THREAD_HOTPLUG_STK_SIZE,
LW_PRIO_T_SYSMSG,
(LW_CFG_HOTPLUG_OPTION | LW_OPTION_THREAD_SAFE | LW_OPTION_OBJECT_GLOBAL),
LW_NULL);
hHotplugThread = API_ThreadCreate("t_hotplug",
(PTHREAD_START_ROUTINE)_hotplugThread,
(PLW_CLASS_THREADATTR)&threadattr,
LW_NULL); /* 建立 job 处理线程 */
if (!hHotplugThread) {
API_SemaphoreMDelete(&_G_hHotplugLock);
_jobQueueFinit(&_G_jobqHotplug);
return (PX_ERROR);
}
_G_hHotplug = hHotplugThread;
#if LW_CFG_DEVICE_EN > 0
_hotplugDrvInstall(); /* 初始化热插拔消息设备 */
_hotplugDevCreate();
#endif /* LW_CFG_DEVICE_EN > 0 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: 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);
}
/*********************************************************************************************************
** 函数名称: _posixAioInit
** 功能描述: 初始化 AIO 函数库
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID _posixAioInit (VOID)
{
_G_aioqueue.aioq_mutex = API_SemaphoreMCreate("aio_mutex", LW_PRIO_DEF_CEILING,
LW_OPTION_DELETE_SAFE | LW_OPTION_INHERIT_PRIORITY, LW_NULL);
if (_G_aioqueue.aioq_mutex == 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "can not initialize mutex.\r\n");
return;
}
if (API_ThreadCondInit(&_G_aioqueue.aioq_newreq, LW_THREAD_PROCESS_SHARED) != ERROR_NONE) {
API_SemaphoreMDelete(&_G_aioqueue.aioq_mutex);
_DebugHandle(__ERRORMESSAGE_LEVEL, "can not initialize thread cond.\r\n");
return;
}
_G_aioqueue.aioq_plinework = LW_NULL;
_G_aioqueue.aioq_plineidle = LW_NULL;
_G_aioqueue.aioq_idlethread = 0;
_G_aioqueue.aioq_actthread = 0;
}
/*********************************************************************************************************
** 函数名称: pthread_rwlock_init
** 功能描述: 创建一个读写锁.
** 输 入 : prwlock 句柄
** prwlockattr 属性块
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
int pthread_rwlock_init (pthread_rwlock_t *prwlock, const pthread_rwlockattr_t *prwlockattr)
{
if (prwlock == LW_NULL) {
errno = EINVAL;
return (EINVAL);
}
prwlock->PRWLOCK_ulRSemaphore = API_SemaphoreCCreate("prwrlock", 0, __ARCH_ULONG_MAX,
LW_OPTION_WAIT_PRIORITY, LW_NULL);
if (prwlock->PRWLOCK_ulRSemaphore == LW_OBJECT_HANDLE_INVALID) {
errno = ENOSPC;
return (ENOSPC);
}
prwlock->PRWLOCK_ulWSemaphore = API_SemaphoreCCreate("prwwlock", 0, __ARCH_ULONG_MAX,
LW_OPTION_WAIT_PRIORITY, LW_NULL);
if (prwlock->PRWLOCK_ulWSemaphore == LW_OBJECT_HANDLE_INVALID) {
API_SemaphoreCDelete(&prwlock->PRWLOCK_ulRSemaphore);
errno = ENOSPC;
return (ENOSPC);
}
prwlock->PRWLOCK_ulMutex = API_SemaphoreMCreate("prwlock_m", LW_PRIO_DEF_CEILING,
(LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_DELETE_SAFE |
LW_OPTION_WAIT_PRIORITY), LW_NULL);
if (prwlock->PRWLOCK_ulMutex == LW_OBJECT_HANDLE_INVALID) {
API_SemaphoreCDelete(&prwlock->PRWLOCK_ulRSemaphore);
API_SemaphoreCDelete(&prwlock->PRWLOCK_ulWSemaphore);
errno = ENOSPC;
return (ENOSPC);
}
prwlock->PRWLOCK_uiOpCounter = 0;
prwlock->PRWLOCK_uiRPendCounter = 0;
prwlock->PRWLOCK_uiWPendCounter = 0;
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: _posixSyslogInit
** 功能描述: 初始化 syslog 库
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID _posixSyslogInit (VOID)
{
INT iFd;
_G_ulSyslogLock = API_SemaphoreMCreate("syslog_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_DELETE_SAFE |
LW_OPTION_OBJECT_GLOBAL, LW_NULL);
if (_G_ulSyslogLock == 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "can not initialize mutex.\r\n");
}
lib_strlcpy(_G_sockaddrunLog.sun_path, LOG_DEFAULT_FILE, sizeof(_G_sockaddrunLog.sun_path));
_G_sockaddrunLog.sun_family = AF_UNIX;
_G_sockaddrunLog.sun_len = (uint8_t)(SUN_LEN(&_G_sockaddrunLog) + 1);
/* 包含最后一个 '\0' */
_G_sockelenLog = _G_sockaddrunLog.sun_len;
iFd = open(LOG_DEFAULT_FILE, O_CREAT | O_RDWR, __PX_SYSLOG_DEF_FLAG | S_IFSOCK);
if (iFd >= 0) {
close(iFd);
}
}
/*********************************************************************************************************
** 函数名称: 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);
}
/*********************************************************************************************************
** 函数名称: __canDevInit
** 功能描述: 创建 CAN 设备
** 输 入 :
** pcanDev CAN 设备
** uiRdFrameSize 接收缓冲区大小
** uiWrtFrameSize 发送缓冲区大小
** 输 出 : ERROR_NONE or PX_ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __canDevInit (__CAN_DEV *pcanDev,
UINT uiRdFrameSize,
UINT uiWrtFrameSize)
{
REGISTER INT iErrLevel = 0;
pcanDev->CAN_ulSendTimeout = LW_OPTION_WAIT_INFINITE; /* 初始化为永久等待 */
pcanDev->CAN_ulRecvTimeout = LW_OPTION_WAIT_INFINITE; /* 初始化为永久等待 */
pcanDev->CAN_pcanqRecvQueue = __canInitQueue(uiRdFrameSize); /* 创建读缓冲区 */
if (pcanDev->CAN_pcanqRecvQueue == LW_NULL) { /* 创建失败 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
pcanDev->CAN_pcanqSendQueue = __canInitQueue(uiWrtFrameSize); /* 创建读缓冲区 */
if (pcanDev->CAN_pcanqSendQueue == LW_NULL) { /* 创建失败 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
iErrLevel = 1;
goto __error_handle;
}
pcanDev->CAN_canstatWriteState.CANSTAT_bBufEmpty = LW_TRUE; /* 发送队列空 */
pcanDev->CAN_uiBusState = CAN_DEV_BUS_ERROR_NONE;
/* 发送队列空 */
pcanDev->CAN_ulRcvSemB = API_SemaphoreBCreate("can_rsync",
LW_FALSE,
LW_OPTION_WAIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
LW_NULL); /* 读同步 */
if (!pcanDev->CAN_ulRcvSemB) {
iErrLevel = 2;
goto __error_handle;
}
pcanDev->CAN_ulSendSemB = API_SemaphoreBCreate("can_wsync",
LW_TRUE,
LW_OPTION_WAIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
LW_NULL); /* 写同步 */
if (!pcanDev->CAN_ulSendSemB) {
iErrLevel = 3;
goto __error_handle;
}
pcanDev->CAN_ulMutexSemM = API_SemaphoreMCreate("can_lock",
LW_PRIO_DEF_CEILING,
(LW_OPTION_WAIT_FIFO |
LW_OPTION_DELETE_SAFE |
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_OBJECT_GLOBAL),
LW_NULL); /* 互斥访问控制信号量 */
if (!pcanDev->CAN_ulMutexSemM) {
iErrLevel = 4;
goto __error_handle;
}
SEL_WAKE_UP_LIST_INIT(&pcanDev->CAN_selwulList); /* 初始化 select 等待链 */
LW_SPIN_INIT(&pcanDev->CAN_slLock); /* 初始化自旋锁 */
return (ERROR_NONE);
__error_handle:
if (iErrLevel > 3) {
API_SemaphoreBDelete(&pcanDev->CAN_ulSendSemB); /* 删除写同步 */
}
if (iErrLevel > 2) {
API_SemaphoreBDelete(&pcanDev->CAN_ulRcvSemB); /* 删除读同步 */
}
if (iErrLevel > 1) {
__canDeleteQueue(pcanDev->CAN_pcanqSendQueue); /* 删除读缓冲区 */
}
if (iErrLevel > 0) {
__canDeleteQueue(pcanDev->CAN_pcanqRecvQueue); /* 删除写缓冲区 */
}
return (PX_ERROR);
}
/*********************************************************************************************************
** 函数名称: API_VmmLibPrimaryInit
** 功能描述: 初始化 vmm 库 (注意: LW_VMM_ZONE_DESC 结构表内的元素数一定要与 LW_CFG_VMM_ZONE_NUM 一致)
** 输 入 : vmzone 物理内存区
** mmugdesc 全局映射关系描述表
** pcMachineName 正在运行的机器名称
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
** 注 意 : 多核模式为主核 MMU 初始化
API 函数
*********************************************************************************************************/
LW_API
ULONG API_VmmLibPrimaryInit (LW_VMM_ZONE_DESC vmzone[],
LW_MMU_GLOBAL_DESC mmugdesc[],
CPCHAR pcMachineName)
{
static BOOL bIsInit = LW_FALSE;
PLW_MMU_VIRTUAL_DESC pvirdesc = __vmmVirtualDesc();
INT i;
ULONG ulError;
ULONG ulPageNum = 0;
if (bIsInit) {
return (ERROR_NONE);
}
if ((vmzone == LW_NULL) || (mmugdesc == LW_NULL)) {
_ErrorHandle(EINVAL);
return (EINVAL);
}
for (i = 0; i < LW_CFG_VMM_ZONE_NUM; i++) {
ulPageNum += (ULONG)(vmzone[i].ZONED_stSize >> LW_CFG_VMM_PAGE_SHIFT);
}
ulError = __pageCbInit(ulPageNum); /* 初始化物理页面控制块池 */
if (ulError) {
_ErrorHandle(ulError);
return (ulError);
}
for (i = 0; i < LW_CFG_VMM_ZONE_NUM; i++) {
ulError = __vmmPhysicalCreate((ULONG)i, vmzone[i].ZONED_ulAddr,
vmzone[i].ZONED_stSize,
vmzone[i].ZONED_uiAttr);/* 初始化物理 zone */
if (ulError) {
_ErrorHandle(ulError);
return (ulError);
}
ulError = __areaPhysicalSpaceInit((ULONG)i, vmzone[i].ZONED_ulAddr,
vmzone[i].ZONED_stSize);
if (ulError) {
_ErrorHandle(ulError);
return (ulError);
}
}
ulError = __vmmVirtualCreate(pvirdesc->ulVirtualStart,
pvirdesc->stSize); /* 初始化逻辑空间 */
if (ulError) {
_ErrorHandle(ulError);
return (ulError);
}
ulError = __areaVirtualSpaceInit(pvirdesc->ulVirtualStart,
pvirdesc->stSize);
if (ulError) {
_ErrorHandle(ulError);
return (ulError);
}
_G_ulVmmLock = API_SemaphoreMCreate("vmm_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_INHERIT_PRIORITY |
LW_OPTION_WAIT_PRIORITY |
LW_OPTION_DELETE_SAFE |
LW_OPTION_OBJECT_GLOBAL, /* 基于优先级等待 */
LW_NULL);
if (!_G_ulVmmLock) {
return (API_GetLastError());
}
__vmmMapInit(); /* 初始化映射管理库 */
ulError = __vmmLibPrimaryInit(mmugdesc, pcMachineName); /* 初始化底层 MMU */
if (ulError) {
_ErrorHandle(ulError);
return (ulError);
}
bIsInit = LW_TRUE;
_DebugHandle(__LOGMESSAGE_LEVEL, "MMU initilaized.\r\n");
return (ERROR_NONE); /* 初始化底层 MMU */
}
