hs_os.c

OS接口代码,实现OS中间件功能,抽取OS接口,........

    lRet = pthread_attr_setschedpolicy(&tTaskAttr, SCHED_FIFO);

    if (lRet != 0)
    {
        hs_debug_print(ERROR_LEVEL, "set schedpolicy failure.\n");
        eRet = HS_ERROR_FAILURE;
        goto err_return;
    }

    lRet = pthread_attr_setschedparam(&tTaskAttr, &tSchedParam);

    if (lRet != 0)
    {
        hs_debug_print(ERROR_LEVEL, "set setschedparam failure.\n");
        eRet =	HS_ERROR_FAILURE;
        goto err_return;
    }
    lRet = pthread_create(&s_atTask[lTaskId].hTaskId, &tTaskAttr, CommonTask, (void * )lTaskId);
    if (lRet != 0)
    {
        hs_debug_print(ERROR_LEVEL, "task create failure.\n");
        eRet = HS_ERROR_FAILURE;
        goto err_return;
    }
    else
    {
        *phTaskHandle = lTaskId
        hs_mutex_release(s_hTaskMutex);
        return HS_NO_ERROR;
    }

    eRet = HS_NO_ERROR;


err_return:

    if (eRet != HS_NO_ERROR && lTaskId >= 0)
    {
        s_atTask[lTaskId].usUsed = FALSE;
        hs_debug_print(ERROR_LEVEL, "TaskCreate err return\n");
    }

    hs_mutex_release(s_hTaskMutex);


    return HS_ERROR_FAILURE;
#endif
}

/***************************************************************************
* Function:
*		HS_OS_TaskCreateEx
*
* Description:
*		创建任务，可设置任务回收类型
*
* Input:
*		szName:		任务名称，不允许重复
*		eFlag:		HS_DETACH,  任务结束后由系统回收
					HS_ATTACH,  任务结束后由必须由其他任务回收
*		pfEntry:		任务入口函数指针
*		pParam:		传递给任务入口函数的参数
*		stackSize:	任务堆栈大小（以字节为单位）
*		priority:		任务优先级（0～255 ），0  最小，255  最大
*
* Output:
*		phTaskHandle:  任务句柄
*
* Return:
*		其他 						- 创建任务失败
*		HS_NO_ERROR				- 创建任务成功
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_TaskCreateEx ( IN S8 szName[], 
                                        IN HS_OS_TaskStyle_e eFlag, 
                                        IN PFTaskEntry pfEntry, 
                                        IN void * pParam, 
                                        IN U32 stackSize, 
                                        IN U32 priority, 
                                        OUT HANDLE *phTaskHandle )
/*EHsRst HS_OS_TaskCreateEx (S8 szName[],ETaskStyle eFlag, U16 usPriority, U32 ulStackSize, 
     PFTaskEntry pfEntry, void * pTaskPara, TASK_ID *phTaskId)*/
{
    S32 lRet;
    S32 lTaskId;
    HS_ErrorCode_e eRet =  HS_NO_ERROR;
	
    pthread_attr_t tTaskAttr;

	if(FALSE == s_bTaskInit)
	{
	   lRet = HS_OS_TaskInit();
	   if(HS_NO_ERROR != lRet)
	   {
	       HS_ERR("task init fail\r\n");
	   }
	}
	else
	{
          HS_INFO("task already be inited\r\n ");
	}
    HS_ASSERT(  TRUE == s_bTaskInit );
	
    if (pfEntry == NULL || priority > MAX_PRIORITY /* || usPriority < MIN_PRIORITY */)
    {
        HS_ERR("input para err\n");
        return HS_ERR_INVALID_PARA;
    }
    
    if (0 == stackSize)
    {
        stackSize = TASK_DEFAULT_STACK_SIZE;
    }
    else if ( TASK_MIN_STACK_SIZE > stackSize)
    {	
        /* the stackSize seem can't be less than 16k*/
        stackSize = TASK_MIN_STACK_SIZE;
    }

	
    HS_OS_MutexLock(s_hTaskMutex, HS_TIMEOUT_INFINITY, NULL);

    lTaskId = FindUnusedTask();
    if (lTaskId < 0)
    {
        HS_ERR("system no valid task to be used\n");

        eRet = HS_ERR_NO_RESOURCE;

        goto err_return;
    }
    
    strncpy(s_atTask[lTaskId].szName, szName, TASK_NAME_MAX_LEN-1);
    s_atTask[lTaskId].szName[TASK_NAME_MAX_LEN-1] = '\0';
	    
    s_atTask[lTaskId].ucPriority = (U8)priority;
    s_atTask[lTaskId].ulStackSize = stackSize;
    s_atTask[lTaskId].eFlag = eFlag;
    s_atTask[lTaskId].pfEntry = pfEntry;
    s_atTask[lTaskId].pArg = pParam;
    s_atTask[lTaskId].usUsed = TRUE; 
   

    lRet = pthread_attr_init(&tTaskAttr);
    if (lRet != 0) 
    { 
        HS_ERR( "set attr failure.\n");
        eRet = HS_FAIL;
        goto err_return;
    }

    lRet = pthread_attr_setstacksize(&tTaskAttr, (int)stackSize);
    if (lRet != 0) 
    { 
        HS_ERR( "set stack size fail\n");
        eRet =  HS_FAIL;
        goto err_return;
    }

/*Jiao change*/
#if 0	
	    pthread_attr_setdetachstate(&tTaskAttr, eFlag);
#else
    lRet = pthread_attr_setdetachstate(&tTaskAttr, 
			eFlag == HS_OS_TASKSTYLE_DETACH?PTHREAD_CREATE_DETACHED: PTHREAD_CREATE_JOINABLE);

    if (lRet != 0) 
    { 
        HS_ERR( "set detach state fail\n");
        eRet =  HS_FAIL;
        goto err_return;
    }
#endif

    if (priority >= 20) /* preemptive task */
    {
        struct sched_param tSchedParam;
	    	
        tSchedParam.sched_priority = priority;
		
        lRet = pthread_attr_setschedpolicy(&tTaskAttr, SCHED_FIFO);

        if (lRet != 0) 
        { 
            HS_ERR( "set schedpolicy failure.\n");
            eRet = HS_FAIL;
            goto err_return;
        }
		
        lRet = pthread_attr_setschedparam(&tTaskAttr, &tSchedParam);
		
        if (lRet != 0) 
        { 
            HS_ERR( "set setschedparam failure.\n");
            eRet =  HS_FAIL;
            goto err_return;
         }
		
    }

		
    lRet = pthread_create(&s_atTask[lTaskId].hTaskId, &tTaskAttr, CommonTask, (void * )lTaskId);
    if (lRet != 0)
    {
        HS_ERR( "task create failure.\n");
        eRet = HS_FAIL;
        goto err_return;
    }
    else
    {
        if (phTaskHandle != NULL)
        {
            *phTaskHandle = lTaskId;
        }
			
    }

    eRet = HS_NO_ERROR;
    

err_return:
	
    if(eRet != HS_NO_ERROR && lTaskId >= 0)
    {
        s_atTask[lTaskId].usUsed = FALSE;
		HS_INFO("HS_OS_TaskCreate err return\n");	
    }
	
    HS_OS_MutexUnlock(s_hTaskMutex);

   
    return eRet;
}

/***************************************************************************
* Function:
*		HS_OS_TaskDelete
*
* Description:
*		删除任务，等待任务结束，并清理任务现场
*
* Input:
*		hTaskHandle:		任务句柄
*
* Output:
*		无
*
* Return:
*		其他 						- 失败
*		HS_NO_ERROR				- 成功
*
* Others:
*		OS21  系统慎用，经常删除任务可能导致系统异常
*
****************************************************************************/
HS_ErrorCode_e HS_OS_TaskDelete (IN HANDLE hTaskHandle)
{
    S32 lRet;

    //lRet = pthread_join(s_atTask[task].hTaskId, NULL);
    lRet = pthread_cancel(s_atTask[hTaskHandle].hTaskId);
    hs_debug_print(INFO_LEVEL, "Using 'cancel' method instead.\n");
    if (lRet != 0)
    {
        hs_debug_print(ERROR_LEVEL, "task delete failed\n");
        return HS_ERROR_FAILURE;
    }


    return HS_NO_ERROR;
}

/***************************************************************************
* Function:
*		HS_OS_TaskKill
*
* Description:
*		删除任务，强行终止指定任务
*
* Input:
*		hTaskHandle:		任务句柄
*
* Output:
*		无
*
* Return:
*		其他 						- 失败
*		HS_NO_ERROR				- 成功
*
* Others:
*		OS21  系统慎用，经常删除任务可能导致系统异常
*
****************************************************************************/
HS_ErrorCode_e HS_OS_TaskKill(IN HANDLE hTaskHandle)
{
    return HS_OS_TaskDelete(hTaskHandle); 
}

/***************************************************************************
* Function:
*		HS_OS_TaskSetPriority
*
* Description:
*		设置任务的优先级
*
* Input:
*		hTaskHandle:		任务句柄
*		priority:			任务优先级，0~255
*
* Output:
*		无
*
* Return:
*		其他 						- 失败
*		HS_NO_ERROR				- 成功
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_TaskSetPriority(IN HANDLE hTaskHandle,IN S32 priority)
{
    S32 lRet;
    struct sched_param param;

    if (priority > MAX_PRIORITY || priority < MIN_PRIORITY)
    {
        hs_debug_print(ERROR_LEVEL, "Priority value out of acceptable range!\n");
        return HS_ERROR_PARA;
    }

    param.sched_priority = priority / 3;
    lRet = pthread_setschedparam(s_atTask[hTaskHandle].hTaskId, SCHED_FIFO, &param);

    if (lRet != 0)
    {
        hs_debug_print(ERROR_LEVEL, "set schedparam failed while modifying task priority\n");
        return HS_ERROR_FAILURE;
    }

    s_atTask[hTaskHandle].ucPriority = priority;

    return HS_NO_ERROR;
}

/***************************************************************************
* Function:
*		HS_OS_TaskGetPriority
*
* Description:
*		获得任务的优先级
*
* Input:
*		hTaskHandle:		任务句柄
*
* Output:
*		pPriority:		优先级
*
* Return:
*		其他 						- 失败
*		HS_NO_ERROR				- 成功
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_TaskGetPriority(IN HANDLE hTaskHandle, OUT S32 *pPriority)
{
    *pPriority = s_atTask[hTaskHandle].ucPriority;
    return HS_NO_ERROR;
}

/***************************************************************************
* Function:
*		HS_OS_TaskGetHandle
*
* Description:
*		根据任务名称获得任务的句柄
*
* Input:
*		pucTaskName:		任务名称
*
* Output:
*		phTaskHandle:	任务句柄
*
* Return:
*		其他 						- 失败
*		HS_NO_ERROR				- 成功
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_TaskGetHandle ( IN U8 *pucTaskName, OUT HANDLE *phTaskHandle )
{
    U32 i;

    for (i = 1; i < MAX_TCB_NUM + 1; i++)
    {
        if (s_atTask[i].usUsed == TRUE)
        {
            if(strcmp(s_atTask[i].szName, pucTaskName))
            {
                *phTaskHandle = i;
                return HS_NO_ERROR;
            }
        }
    }
    return HS_ERROR_FAILURE;
}


/*******************************************************************
**		信号量相关函数接口
*******************************************************************/

typedef struct OS_InnerSem_s
{
	sem_t 	semHandle;
	U32		totalNum;
	S32		curNum;
}OS_InnerSem_t;

/***************************************************************************
* Function:
*		HS_OS_SemaphoreCreate
*
* Description:
*		创建信号量（FIFO  ）
*
* Input:
*		tokenNumber:		指定该信号量的信号个数，如果用该信号量来
*						保护某资源，该个数则表明可以有多少个任务
*						同时访问该资源
*		initValue:			初始值
*
* Output:
*		phSempHandle:	信号量句柄
*
* Return:
*		其他 						- 失败
*		HS_NO_ERROR				- 成功
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_SemaphoreCreate ( 
                                IN S32 tokenNumber, 
                                IN U32 initValue, 
                                OUT HANDLE *phSempHandle )
{
    S32 			 ret 		= 0;
	OS_InnerSem_t	*p_sem 		= NULL_POINTER(OS_InnerSem_t *);

    if(tokenNumber <= 0)
    {
        hs_debug_error(("Invalid Token number.\n"));
        return HS_ERROR_PARA;
    }

	p_sem = (OS_InnerSem_t *)HS_MALLOC(sizeof(OS_InnerSem_t));
    if (p_sem EQUAL NULL_POINTER(OS_InnerSem_t *))
    {
		hs_debug_error(("Have not enought memory.\n"));
		return HS_ERROR_NO_MEMORY;
	}
	
	p_sem->totalNum = tokenNumber;
	p_sem->curNum	= initValue;
	
    ret = sem_init(&p_sem->semHandle, 0, initValue);
    if(ret !=0)
    {
		HS_FREE(p_sem);
		
        hs_debug_error(("Semaphore Create Failed!\n"));		
        return HS_ERROR_FAILURE;
    }

    *phSempHandle = (HANDLE)p_sem;
    return HS_NO_ERROR;
}

/***************************************************************************
* Function:
*		HS_OS_CreateSemaphoreEx
*
* Description:
*		创建信号量（基于优先级或FIFO  ）
*
* Input:
*		eType:			指定信号量的类型（基于优先级 or 基于FIFO）
*		tokenNumber:		指定该信号量的信号个数，如果用该信号量来
*						保护某资源，该个数则表明可以有多少个任务
*						同时访问该资源
*		initValue:			初始值
*
* Output:
*		phSempHandle:	信号量句柄
*
* Return:
*		其他 						- 失败
*		HS_NO_ERROR				- 成功
*
* Others:
*
****************************************************************************/
HS_ErrorCode_e HS_OS_SemaphoreCreateEx(
								IN HS_OS_SemaphoreType_e eType, 
								IN S32 tokenNumber,	
								IN U32 initValue,  
								OUT HANDLE * phSempHandle )