コード例 #1
0
ファイル: resourceLib.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: _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);
}
コード例 #2
0
ファイル: aio_lib.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: __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);
}
コード例 #3
0
ファイル: hotplugDev.c プロジェクト: Ryanxjl/libsylixos-mips
/*********************************************************************************************************
** 函数名称: _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);
}
コード例 #4
0
/*********************************************************************************************************
** 函数名称: _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);
}
コード例 #5
0
ファイル: pciDev.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: 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);
}
コード例 #6
0
ファイル: eventfdDev.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: 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));
}
コード例 #7
0
ファイル: ttinyShell.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: 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 命令             */
    }
}
コード例 #8
0
ファイル: lwip_netifnum.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: 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);
    }
}
コード例 #9
0
ファイル: hotplugLib.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: _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);
}
コード例 #10
0
ファイル: pthread_key.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: 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);
}
コード例 #11
0
ファイル: aio_lib.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: _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;
}
コード例 #12
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);
}
コード例 #13
0
ファイル: syslog.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: _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);
    }
}
コード例 #14
0
ファイル: romFs.c プロジェクト: Ryanxjl/libsylixos-mips
/*********************************************************************************************************
** 函数名称: 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);
}
コード例 #15
0
ファイル: can.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: __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);
}
コード例 #16
0
ファイル: vmm.c プロジェクト: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: 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              */
}