ssp_task.c

abstract rtos

    aos_int_unlock( lockKey );
    
    return AOS_SUCC;
}

VOID aos_task_lock( )
{
    (void)sys_task_lock();
}

VOID aos_task_unlock( )
{
    (void)sys_task_unlock();
}

VOID aos_task_yield( )
{
    sys_task_unlock(); 
    sys_task_delay(0); 
    sys_task_lock();   
}


VOID aos_task_yield_time( )
{
    if( m_ulCurTicks >= CONFIG_TICKS_ONCE_PROCESS )
    {
        sys_task_unlock(); 
        sys_task_delay(0); 
        sys_task_lock();   
    }
}

U32 aos_task_name(U32 task_id,S8 *szName)
{
    TASK_S * pTask;
    U32      i;

    if(szName == NULL)
    {
        return AOS_FAIL;
    }
    
    if( 0 == task_id )
    {
        task_id = aos_task_self();
    }

    if( task_id >= CONFIG_TASK_NUMBER )
    {
        szName[AOS_NAME_LEN] = '\0';
        return AOS_FAIL;
    }

    pTask = &g_pstTask[task_id];
    if( TASK_STATUS_NULL == pTask->status )
    {
        szName[AOS_NAME_LEN] = '\0';
        return AOS_FAIL;
    }

    for(i = 0;i < AOS_NAME_LEN;i++)
    {
        szName[i] = (S8)(pTask->name[i]);
    }
    szName[AOS_NAME_LEN] = '\0';

    return AOS_SUCC;
}

U32 aos_task_status(U32 task_id,S8 * szStatus)
{
    TASK_S * pTask;

    if(szStatus == NULL)
    {
        return AOS_FAIL;
    }
    if( 0 == task_id )
    {
        task_id = aos_task_self();
    }

    if( task_id >= CONFIG_TASK_NUMBER )
    {
        szStatus[AOS_NAME_LEN*2] = '\0';
        return AOS_FAIL;
    }

    pTask = &g_pstTask[task_id];
    if( TASK_STATUS_NULL == pTask->status )
    {
        szStatus[AOS_NAME_LEN*2] = '\0';
        return AOS_FAIL;
    }

    return sys_task_status(pTask->sys_task_hd,szStatus);
    
}

U32 aos_task_sp(U32 task_id)
{
    TASK_S * pTask;
        
    if( 0 == task_id )
    {
        task_id = aos_task_self();
    }

    if( task_id >= CONFIG_TASK_NUMBER )
    {
        return 0;
    }

    pTask = &g_pstTask[task_id];
    if( TASK_STATUS_NULL == pTask->status )
    {
        return 0;
    }

    return sys_task_sp(pTask->sys_task_hd);
}

U32 aos_task_bp(U32 task_id)
{
    TASK_S * pTask;
        
    if( 0 == task_id )
    {
        task_id = aos_task_self();
    }

    if( task_id >= CONFIG_TASK_NUMBER )
    {
        return 0;
    }

    pTask = &g_pstTask[task_id];
    if( TASK_STATUS_NULL == pTask->status )
    {
        return 0;
    }

    return sys_task_bp(pTask->sys_task_hd);
}

U32 aos_task_pc(U32 task_id)
{
    TASK_S * pTask;
        
    if( 0 == task_id )
    {
        task_id = aos_task_self();
    }

    if( task_id >= CONFIG_TASK_NUMBER )
    {
        return 0;
    }

    pTask = &g_pstTask[task_id];
    if( TASK_STATUS_NULL == pTask->status )
    {
        return 0;
    }

    return sys_task_pc(pTask->sys_task_hd);
}

U32 aos_task_stackactsize(U32 ulTaskID)
{
    TASK_S * pTask;
    U32 bp;
    U32 top,bottom;
    U32 ulActSize;

    if( 0 == ulTaskID )
    {
        ulTaskID = aos_task_self();
    }

    if( ulTaskID >= CONFIG_TASK_NUMBER )
    {
        return 0;
    }

    pTask = &g_pstTask[ulTaskID];

    bp          = aos_task_bp(ulTaskID);
    bottom      = bp;
    top         = bottom - pTask->stack_size + 64;

    
    
    while(((*(U32 *)bp) != SPY_STACK_DEFAULT_VALUE) || ((*((U32 *)bp+1)) != SPY_STACK_DEFAULT_VALUE)
        || ((*((U32 *)bp+2)) != SPY_STACK_DEFAULT_VALUE) || ((*((U32 *)bp+3)) != SPY_STACK_DEFAULT_VALUE))
    {
        bp -= 16;
        if(bp <= top)
        {
            break;
        }
    }

    ulActSize = bottom - bp;
    if(ulActSize > pTask->stack_size)
    {
        ulActSize = pTask->stack_size;
    }
    
    return ulActSize;
}

#if( CONFIG_CPU_PPC == TRUE ) || (CONFIG_OS_WINDOWS == TRUE )
VOID aos_task_show_call_stack(U32 level)
{
    U32 sp, pc, tSelf, showed;

    tSelf = aos_task_self();
    if(U32_BUTT == tSelf)
    {
        return;
    }
        
    aos_printf(0,"show call stack of task %s", g_pstTask[tSelf].name );

    sp = sys_get_cur_sp();
    if( 0 == sp || sp >= (U32)g_pstTask[tSelf].stack_bottom )
    {
        return;
    }

    aos_printf(0,"stid=0x%x, bp = 0x%x",g_pstTask[tSelf].sys_task_id, aos_task_bp(tSelf) );

    if(!level)
    {
        level--;
    }

    
    showed = 0;
    while( level-->0 )
    {
        if( showed >= MAX_CALL_STACK_LEVEL )
        {
            break;
        }
        
        if( 0 ==sp || sp >= (U32)g_pstTask[tSelf].stack_bottom )
        {
            break;
        }
        showed++;
        sp = *(U32*)sp;
        pc = *(U32*)(sp+4);
        aos_printf(0,"instr 0x%x, sp:0x%x",pc,sp);
    }
}

#elif( CONFIG_CPU_ARM == TRUE ) 
VOID aos_task_show_call_stack(U32 level)
{
    U32 fp, pc, sp, tSelf, showed,lr;
    
    tSelf = aos_task_self();
    if(U32_BUTT == tSelf)
    {
        return;
    }
        
    aos_printf(0,"show call stack of task %s", g_pstTask[tSelf].name );

    fp = sys_get_cur_fp();
    if( 0 == fp || fp >= (U32)g_pstTask[tSelf].stack_bottom )
    {
        return;
    }

    aos_printf(0,"stid=0x%x, bp = 0x%x",g_pstTask[tSelf].sys_task_id, aos_task_bp(tSelf) );

    if(!level)
    {
        level--;
    }

    
    fp = *(U32*)(fp-12);
    showed = 0;
    while( level-->0 )
    {
        if( showed >= MAX_CALL_STACK_LEVEL )
        {
            break;
        }
        
        if( 0 ==fp || fp >= (U32)g_pstTask[tSelf].stack_bottom )
        {
            break;
        }

        
        pc = *(U32*)(fp);
        lr = *(U32*)(fp-4);
        sp = *(U32*)(fp-8);
        aos_printf(0,"instr 0x%x, lr 0x%x, sp 0x%x, fp 0x%x",pc,lr, sp, fp);
        
        fp = *(U32*)(fp-12);
    }
}
#elif( CONFIG_CPU_MIPS == TRUE ) 
#if ( __BIG_ENDIAN == TRUE )
VOID aos_task_show_call_stack(U32 level)
{
   
    U32 sp, pc, tSelf, showed,cnt,instr,cnt_clear;
    
    tSelf = aos_task_self();
    if(U32_BUTT == tSelf)
    {
        return;
    }
        
    aos_printf(0,"show call stack of task %s", g_pstTask[tSelf].name );

    sp = sys_get_cur_fp();
    if( sp >= (U32)g_pstTask[tSelf].stack_bottom || sp < 0x80000000 )
    {
        return;
    }

    aos_printf(0,"stid=0x%x, bp = 0x%x",g_pstTask[tSelf].sys_task_id, aos_task_bp(tSelf) );

    if(!level)
    {
        level--;
    }
    
    showed = 0;
    cnt_clear = 0;


    pc = *(U32*)(sp+52);
    sp = *(U32*)(sp+48);
    while( level-->0 )
    {
        if( showed >= MAX_CALL_STACK_LEVEL )
        {
            break;
        }
        
        if( sp >= (U32)g_pstTask[tSelf].stack_bottom || sp < 0x80000000 )
        {
            break;
        }
        showed++;
        pc = *(U32*)(sp-4);
        aos_printf(0,"instr 0x%x, sp:0x%x",pc,sp);

#define INSTR_JR         0x03e00008
#define INSTR_SP_RESTORE 0x27bd0000
#define INSTR_MASK       0xffff0000
#define INSTR_SP_MASK    0xffff
        
        instr = 0;
        pc += 4;
        for( cnt=0; pc > 0x80000000 && cnt < 2000; pc +=4,cnt++,cnt_clear++ )
        {
            instr = *(U32*)pc;
            if( instr == INSTR_JR )
            {
                break;
            }

            if( 0 == (cnt_clear %1000) )
            {
                clear_watch_dog();
            }
        }
        if( instr != INSTR_JR )
        {
            aos_printf( 0, "function too big!!!!" );
            break;
        }
        pc -= 4;
        instr = *(U32*)pc;
        if( (instr & INSTR_MASK) != INSTR_SP_RESTORE )
        {
            aos_printf( 0, "abnormal invoke!!!!" );
            break;
        }

        sp += instr & INSTR_SP_MASK;

#undef INSTR_JR
#undef INSTR_SP_RESTORE
#undef INSTR_SP_MASK
#undef INSTR_MASK
    }
}
#else
VOID aos_task_show_call_stack(U32 level)
{
   
    U32 sp, pc, tSelf, showed,cnt,instr,cnt_clear,ra,ra_find;
    
    tSelf = aos_task_self();
    if(U32_BUTT == tSelf)
    {
        return;
    }

    aos_printf(0,"show call stack of task %s", g_pstTask[tSelf].name );

    sp = sys_get_cur_sp();
    if( sp >= (U32)g_pstTask[tSelf].stack_bottom || sp < 0x80000000 )
    {
        return;
    }

    aos_printf(0,"stid=0x%x, bp=0x%x, sp=0x%x, stack_bottom=0x%x",
        g_pstTask[tSelf].sys_task_id, aos_task_bp(tSelf), sp,g_pstTask[tSelf].stack_bottom );

    if(!level)
    {
        level--;
    }

    
    showed = 0;
    cnt_clear = 0;

    pc = (U32)sys_get_cur_pc();
    while( level-->0 )
    {
        if( showed >= MAX_CALL_STACK_LEVEL )
        {
            break;
        }
        
        if( sp >= (U32)g_pstTask[tSelf].stack_bottom || sp < 0x80000000 )
        {
            break;
        }

#define INSTR_SP_OPEN    0x27bd0000 
#define INSTR_SP_MASK    0xffff
#define INSTR_RA_STORE   0xafbf0000 
#define INSTR_RA_MASK    0xffff
#define INSTR_MASK       0xffff0000

        
        instr = 0;
        ra = 0;
        ra_find = 0;
        for( cnt=0; pc > 0x80000000 && cnt < 2000; pc -=4,cnt++,cnt_clear++ )
        {
            instr = *(U32*)pc;
            if( (instr & INSTR_MASK) == INSTR_SP_OPEN )
            {
                break;
            }

            if( (instr & INSTR_MASK) == INSTR_RA_STORE )
            {
                ra_find = 1;
                ra = *(U32*)( sp + (instr & INSTR_RA_MASK) );
            }

            if( 0 == (cnt_clear %1000) )
            {
                clear_watch_dog();
            }
        }
        if( !instr || ((instr & INSTR_MASK) != INSTR_SP_OPEN) )
        {
            aos_printf( 0, "function too big!!!!cnt=%u,pc=0x%x,instr=0x%x",cnt,pc,instr );
            break;
        }
        if( !ra_find )
        {
            aos_printf( 0, "abnormal invoke,can't find ra store instr!!!!,pc=0x%x,instr=0x%x",pc,instr );
            break;
        }

        showed++;
        aos_printf(0,"instr 0x%x, sp:0x%x",ra,sp);

        sp += -(S16)(instr & INSTR_SP_MASK);
        pc = ra;

#undef INSTR_SP_OPEN  
#undef INSTR_SP_MASK  
#undef INSTR_RA_STORE 
#undef INSTR_RA_MASK  
    }
}
#endif


#else
#error unknown product!!!
#endif

void aos_task_switchhook(U32 ulLastTaskId, U32 ulNextTaskId)
{
    g_ulLastTaskID = ssp_task_osidTOaosid(ulLastTaskId);
    g_ulNextTaskID = ssp_task_osidTOaosid(ulNextTaskId);

#if(CONFIG_OS_VXWORKS == TRUE && CONFIG_BOARD_GDSP == TRUE)
    ssp_stack_check(g_ulLastTaskID);
    ssp_stack_check(g_ulNextTaskID);
#endif

    ssp_add_task_switch_track(ulLastTaskId,ulNextTaskId);
    
    g_ulRefresh  = TRUE;

    
    {
        CPU_TICK_S nowTick;

        
        if((g_ulLastTaskID < CONFIG_TASK_NUMBER) &&(g_ulLastTaskID > 0))
        {
            aos_cputick_get(&nowTick);
            aos_cputick_sub(&nowTick,&(g_pstTask[g_ulLastTaskID].cputicklast));
            aos_cputick_add(&(g_pstTask[g_ulLastTaskID].cputicktotal),&nowTick);
            if( g_pstTask[g_ulLastTaskID].status )
            {
                g_pstTask[g_ulLastTaskID].status = TASK_STATUS_PENDED;            
            }
        }

        
        if((g_ulNextTaskID < CONFIG_TASK_NUMBER) &&(g_ulNextTaskID > 0))
        {
            aos_cputick_get(&(g_pstTask[g_ulNextTaskID].cputicklast));
            g_pstTask[g_ulNextTaskID].status = TASK_STATUS_RUNNING;
        }
    }
}


U32 ssp_task_switchhookadd()
{
    S32 result;

    #if CONFIG_OS_WINDOWS
    result = AOS_SUCC;
    #endif
    
    #if CONFIG_OS_VXWORKS
    result = taskSwitchHookAdd((FUNCPTR)sys_task_switchhook);
    if(result != OK)
    {
        return AOS_FAIL;
    }
    #endif

    (void)result;
    return AOS_SUCC;
}

U32 ssp_task_osidTOaosid(U32 ulTaskID)
{
    #if CONFIG_OS_WINDOWS
    U32 i;

    for(i = 1;i < CONFIG_TASK_NUMBER;i++)
    {
        if((U32)(g_pstTask[i].sys_task_id) == ulTaskID)
        {
            return i;
        }
    }

    return U32_BUTT;
    #endif

    #if CONFIG_OS_VXWORKS
    WIND_TCB *pTaskTcb;

    pTaskTcb = (WIND_TCB *)ulTaskID;
    if((pTaskTcb == NULL) || ((U32)pTaskTcb->reserved1 != 0xABCDABCD))
    {
        return U32_BUTT;
    }

    return (U32)pTaskTcb->reserved2;
    #endif
}

VOID ssp_task_entry( U32 task_id )
{
    U32    ulOverFlowFlag = SPY_STACK_BOTTOM_VALUE;
    TASK_S *pTask;
    
	AOS_TRACE_IN( ssp_task_entry, task_id, 0, 0, 0 );
	
    (VOID)ulOverFlowFlag;
    
    if( (task_id >= CONFIG_TASK_NUMBER)
         ||(TASK_STATUS_NULL == g_pstTask[task_id].status) )
    {
        AOS_TRACE_OUT( 1, 0, 0, 0 );
        sys_task_cancel(0);
    }

    pTask = & g_pstTask[task_id];
    pTask->stack_bottom  = &ulOverFlowFlag;
    
    sys_sem_wait( &pTask->sys_event.sys_sem, 0 );
    
    if( AOS_TASK_NOPREEMPT & pTask->task_mode )
    {
        sys_task_lock();
    }
    
    if( pTask->entry )
    {
        pTask->entry(  pTask->arg );
    }

    AOS_TRACE_OUT( 0, 0, 0, 0 );
    aos_task_cancel(0);
}


U32 ssp_has_starve_task()
{
    U32 tSelf, tid, has_starve_task = FALSE;
    TASK_S *pTask = &g_pstTask[1];
    U64 now;

    U32 sec,usec;
        
    tSelf = aos_task_self();

        
    for( tid = 1; tid < CONFIG_TASK_NUMBER; tid++,pTask++ )
    {
        if(  (TASK_STATUS_NULL == pTask->status )
           ||( tid == tSelf )
           ||( tid == m_ulIdleTaskId )
           ||( FALSE == sys_task_is_ready(pTask->sys_task_hd) ) )
        {
            continue;
        }

        if( TASK_STATUS_PENDED == pTask->status )
        {
            
            aos_cputick_get(&pTask->cputicklast);
            pTask->status = TASK_STATUS_READY;
            continue;
        }
        else if( TASK_STATUS_READY == pTask->status )
        {
            aos_cputick_get(&now);
            aos_cputick_sub( &now, &pTask->cputicklast );

            
            if( aos_cputick_compare( &now, &g_cputStarve ) >= 0 )
            {
                aos_cputick_2us( &now, &sec, &usec );
                aos_printf( MPE_TASK, "TASK starves, name=%s, priority=%d, "
                    "starve for (%us,%uus)", 
                    pTask->name, pTask->task_prio, sec, usec );

                
                pTask->status = TASK_STATUS_STARVE;
                has_starve_task = TRUE;
            }
        }
    }

    return has_starve_task;
}

#ifdef __cplusplus
}
#endif