Esempio n. 1
0
/*********************************************************************************************************
** 函数名称: _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);
}
Esempio n. 2
0
/*********************************************************************************************************
** 函数名称: 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);
}
Esempio n. 3
0
/*********************************************************************************************************
** 函数名称: __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);
}
Esempio n. 4
0
/*********************************************************************************************************
** 函数名称: __canDevDelete
** 功能描述: 删除 CAN 设备资源
** 输 入  :
**           pcanDev           CAN 设备
** 输 出  : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __canDevDelete (__CAN_DEV *pcanDev)
{
    __canDeleteQueue(pcanDev->CAN_pcanqRecvQueue);
    __canDeleteQueue(pcanDev->CAN_pcanqSendQueue);

    API_SemaphoreBDelete(&pcanDev->CAN_ulRcvSemB);
    API_SemaphoreBDelete(&pcanDev->CAN_ulSendSemB);
    API_SemaphoreMDelete(&pcanDev->CAN_ulMutexSemM);
}
Esempio n. 5
0
/*********************************************************************************************************
** 函数名称: __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);
}
Esempio n. 6
0
/*********************************************************************************************************
** 函数名称: pthread_rwlock_destroy
** 功能描述: 销毁一个读写锁.
** 输 入  : prwlock        句柄
** 输 出  : ERROR CODE
** 全局变量: 
** 调用模块: 
                                           API 函数
*********************************************************************************************************/
LW_API 
int  pthread_rwlock_destroy (pthread_rwlock_t  *prwlock)
{
    if (prwlock == LW_NULL) {
        errno = EINVAL;
        return  (EINVAL);
    }
    
    if (API_SemaphoreCDelete(&prwlock->PRWLOCK_ulRSemaphore)) {
        errno = EINVAL;
        return  (EINVAL);
    }
    API_SemaphoreCDelete(&prwlock->PRWLOCK_ulWSemaphore);
    API_SemaphoreMDelete(&prwlock->PRWLOCK_ulMutex);
    
    return  (ERROR_NONE);
}
Esempio n. 7
0
/*********************************************************************************************************
** 函数名称: _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);
}
Esempio n. 8
0
/*********************************************************************************************************
** 函数名称: _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;
}
Esempio n. 9
0
/*********************************************************************************************************
** 函数名称: __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);
}
Esempio n. 10
0
/*********************************************************************************************************
** 函数名称: 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);
}