ssp_spy.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif

#include "syscfg.h"
#if( AOS_INCLUDE_SSP_KER_SPY == TRUE )
#include "sys/sys_pub.h"
#include "aos.h"
#include "ssp_event.h"
#include "ssp_task.h"
#include "ssp_msg.h"
#include "ssp_cputick.h"
#include "ssp_spy.h"
#include "ssp_debug.h"


TASK_INFINITE_LOOP_TRACE_S *g_pTaskInfiniteLoopTrace;


U32 g_ulTickIsrCtr;


U32 g_ulAnchor;


U32 g_ulTaskSpy = SPY_OFF;


U32 g_ulContinueTime;



CPU_TICK_S start_tick={0,0};

DBG_POOL_S *dbg_pool = NULL;
U32         m_ulTraceSn = 0;
U32         g_ulEnableTrace = FALSE;
U32         g_ulIsSoftwareResetLastTime = 0;

extern EXCEPTION_BUF_S *g_pException;
extern void drv_cpu_reset( void );
extern char * sysMemTop (void);
#if( CONFIG_BOARD_GMPU != TRUE )
extern char * sysPhysMemTop(void);
#endif
void dbg_dbg_info_cache_flush();








U32 m_spy_init()
{
   
    g_pTaskInfiniteLoopTrace = &dbg_pool->dbg_info[dbg_pool->cur_dbg_index].infinite_loop_task;
    if(g_pTaskInfiniteLoopTrace->m_ulInitFlag != SPY_INIT_FLAG)
    {
        aos_memzero((VOID *)g_pTaskInfiniteLoopTrace,sizeof(TASK_INFINITE_LOOP_TRACE_S));
        g_pTaskInfiniteLoopTrace->m_ulInitFlag = SPY_INIT_FLAG;
        g_pTaskInfiniteLoopTrace->m_ulIndex    = 0;
    }

    g_ulRefresh     = FALSE;
    g_ulTickIsrCtr  = 0;
    g_ulAnchor      = 0;
#if(CONFIG_OS_VXWORKS == TRUE)
    g_ulTaskSpy     = SPY_ON;
#elif(CONFIG_OS_WINDOWS == TRUE)
    g_ulTaskSpy     = SPY_OFF;
#endif
    g_ulContinueTime= SPY_RUN_TICK;

    
    aos_cputick_get(&start_tick);
    
    return AOS_SUCC;
}








VOID ssp_task_spy()
{
#if( CONFIG_OS_VXWORKS == TRUE )
    U32 lockKey;
    U32 ulCurTaskId;
    U32 bp,sp;
    U32 i; 
    
    if(g_pTaskInfiniteLoopTrace->m_ulInitFlag != SPY_INIT_FLAG)
    {
        return;
    }
    
    if (SPY_OFF == g_ulTaskSpy)
    {
        return;
    }

    lockKey = aos_int_lock();
    
    if (TRUE == g_ulRefresh)
    {
        g_ulRefresh     = FALSE;
        g_ulAnchor      = 0;
        g_ulTickIsrCtr  = 0;
    }

    g_ulTickIsrCtr ++;

    
    if (0 == (g_ulTickIsrCtr % SPY_ISR_TICK))
    {
        
        ulCurTaskId = aos_task_self();
        if ((g_ulTickIsrCtr > g_ulContinueTime) && 
            (ulCurTaskId > 0) && (ulCurTaskId < CONFIG_TASK_NUMBER))
        {
            TASK_INFINITE_LOOP_ITEM_S * pTaskItem;
            SYS_TIME_S DateTime;

            
            pTaskItem = g_pTaskInfiniteLoopTrace->m_aItem + g_pTaskInfiniteLoopTrace->m_ulIndex;
            
            if( (0 != pTaskItem->m_ulTaskId) && (ulCurTaskId != pTaskItem->m_ulTaskId) )
            {
                g_pTaskInfiniteLoopTrace->m_ulIndex = (g_pTaskInfiniteLoopTrace->m_ulIndex + 1) % SPY_TASK_NUM;            
                pTaskItem = g_pTaskInfiniteLoopTrace->m_aItem + g_pTaskInfiniteLoopTrace->m_ulIndex;
            }
            pTaskItem->m_ulTaskId = ulCurTaskId;
            
            aos_memcpy(pTaskItem->m_cName,
                       g_pstTask[ulCurTaskId].name,AOS_NAME_LEN);
            pTaskItem->m_ulPowerOn = 1;

            if(g_ulAnchor == 0)
            {
                g_ulAnchor = 1;
                pTaskItem->m_ulLoop ++;
            }
            
            
            aos_time_get(&DateTime);
            pTaskItem->m_uDate      = DateTime.date;
            pTaskItem->m_uHour      = DateTime.hour;
            pTaskItem->m_uMinute    = DateTime.minute;
            pTaskItem->m_uSecond    = DateTime.second;
            pTaskItem->m_ulMillisec = DateTime.millisec;
            pTaskItem->m_ulRunTick  = g_ulTickIsrCtr;
            if (g_ulTickIsrCtr > pTaskItem->m_ulMaxTick)
            {
                pTaskItem->m_ulMaxTick = g_ulTickIsrCtr;
            }

            pTaskItem->m_ulPc = sys_task_pc(0);
            pTaskItem->m_ulSp = sys_get_cur_sp();
            
            bp = sys_task_bp(0);
            sp = pTaskItem->m_ulSp;

            
            {
#ifndef _EIA2000V5
                if( bp < (U32)sysMemTop() )
                {
                    for(i = 0;i < EXCEPTION_STACK_SIZE;i++)
                    {
                        if((sp + i) < bp)
                        {
                            pTaskItem->m_aStack[i] = *(U32 *)(sp+i);
                        }
                        else
                        {
                            pTaskItem->m_aStack[i] = 0;
                        }
                    }
                }
                
                else
#endif
                {
                    for(i = 0;i < EXCEPTION_STACK_SIZE;i++)
                    {
                        pTaskItem->m_aStack[i] = 0xEE;
                    }
                }
            }
            
            {
                i = 0;
                pTaskItem->m_aStackLayer[i].stack_addr     = sp;
                pTaskItem->m_aStackLayer[i].next_inst_addr = pTaskItem->m_ulPc;
                i++;
#ifndef _EIA2000V5
                if( sp < (U32)sysMemTop() )
                {
                    sp = *(U32 *)sp;
                    for ( ; (i< EXCEPTION_STACK_LAYER) && (sp != 0); i++ )
                    {
                        if( sp < ((U32)sysMemTop()-4) )
                        {
                            pTaskItem->m_aStackLayer[i].stack_addr     = sp;
                            pTaskItem->m_aStackLayer[i].next_inst_addr = *(U32 *)(sp + 4);
                            sp = *(U32 *)sp;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
#endif
                if( i < EXCEPTION_STACK_LAYER )
                {
                    pTaskItem->m_aStackLayer[i].stack_addr     = sp;
                    pTaskItem->m_aStackLayer[i].next_inst_addr = 0xBAD00BAD;
                    i++;
                }
                if( i < EXCEPTION_STACK_LAYER )
                {
                    pTaskItem->m_aStackLayer[i].stack_addr     = NULL;
                    pTaskItem->m_aStackLayer[i].next_inst_addr = NULL;
                }
            }
            
            dbg_dbg_info_cache_flush();

            
            if( g_ulTickIsrCtr >= SPY_RUN_DEADLINE_IN_TICK )
            {
                dbg_force_reset();
            }
         }
        
    }
    
    aos_int_unlock(lockKey);
#endif    
}

TASK_INFINITE_LOOP_TRACE_S* ssp_get_task_infinite_loop_cb_base()
{
    return g_pTaskInfiniteLoopTrace;
}







VOID ssp_stack_spy()
{
     
    U32 lockKey;
    U32 bp;
    U32 top;
    U32 ulTaskID;
    U32 ulStackSize;
    S8  cName[AOS_NAME_LEN+1];
    S8 *cStackOverFlowDown = "\r\nstack overflow down,task:%s,bp=0x%x,"
                             "stack size=0x%x.\r\n";
    S8 *cStackOverFlowUp   = "\r\nstack overflow up,task:%s,bp=0x%x,"
                             "stack size=0x%x.\r\n";
    S8 *cStackOverFlow     = "\r\nstack overflow,task:%s,bp=0x%x,"
                             "stack size=0x%x.\r\n";

    ulTaskID = aos_task_self();
    if(ulTaskID == U32_BUTT)
    {
        
        return;
    }


    lockKey = aos_int_lock();

    if( (TASK_STATUS_CREATE == g_pstTask[ulTaskID].status)
      ||(NULL ==g_pstTask[ulTaskID].stack_bottom) )
    {
        aos_int_unlock(lockKey);
        return;
    }

    bp          = aos_task_bp(ulTaskID);
    ulStackSize = g_pstTask[ulTaskID].stack_size;
    top         = bp - ulStackSize + 64;

    aos_task_name(ulTaskID,cName);
    
    if((*(U32 *)top != SPY_STACK_DEFAULT_VALUE) && 
       (*(g_pstTask[ulTaskID].stack_bottom) != SPY_STACK_BOTTOM_VALUE))
    {
        dbg_dbg_info_cache_flush();
        aos_int_unlock(lockKey);

        aos_printf(MPE_SYS,cStackOverFlow,cName,bp,ulStackSize);
        return;
    }

    if(*(U32 *)top != SPY_STACK_DEFAULT_VALUE)
    {
        dbg_dbg_info_cache_flush();
        aos_int_unlock(lockKey);
        aos_printf(MPE_SYS,cStackOverFlowUp,cName,bp,ulStackSize);
        
        return;
    }

    if(*(g_pstTask[ulTaskID].stack_bottom) != SPY_STACK_BOTTOM_VALUE)
    {
        dbg_dbg_info_cache_flush();
        aos_int_unlock(lockKey);
        aos_printf(MPE_SYS,cStackOverFlowDown,cName,bp,ulStackSize);

        return;
    }

    aos_int_unlock(lockKey);

}








VOID ssp_stack_check(U32 ulTaskID)
{
    static BOOL bIsRecord = TRUE;
    U32 lockKey;
    U32 bp;
    U32 top;
    U32 ulStackSize;
    S8  cName[AOS_NAME_LEN+1];
    S8 *cStackOverFlowDown = "\r\nstack overflow down,task:%s,bp=0x%x,"
                             "stack size=0x%x.\r\n";
    S8 *cStackOverFlowUp   = "\r\nstack overflow up,task:%s,bp=0x%x,"
                             "stack size=0x%x.\r\n";
    S8 *cStackOverFlow     = "\r\nstack overflow,task:%s,bp=0x%x,"
                             "stack size=0x%x.\r\n";

    if(ulTaskID >= CONFIG_TASK_NUMBER)
    {
        return;
    }
    
    lockKey = aos_int_lock();

    if( (TASK_STATUS_CREATE == g_pstTask[ulTaskID].status)
      ||(NULL ==g_pstTask[ulTaskID].stack_bottom) 
      || TRUE == g_pstTask[ulTaskID].bisVxSysCreate)
    {
        aos_int_unlock(lockKey);
        return;
    }

    bp          = aos_task_bp(ulTaskID);
    ulStackSize = g_pstTask[ulTaskID].stack_size;
    top         = bp - ulStackSize + 64;

    aos_task_name(ulTaskID,cName);
    
    if((*(U32 *)top != SPY_STACK_DEFAULT_VALUE) && 
       (*(g_pstTask[ulTaskID].stack_bottom) != SPY_STACK_BOTTOM_VALUE))
    {
        dbg_dbg_info_cache_flush();
        aos_int_unlock(lockKey);

        
        if(bIsRecord)
        {
            AOS_ASSERT(0);
            aos_printf(MPE_SYS,cStackOverFlow,cName,bp,ulStackSize);
            bIsRecord = FALSE;
        }
        return;
    }

    if(*(U32 *)top != SPY_STACK_DEFAULT_VALUE)
    {
        dbg_dbg_info_cache_flush();
        aos_int_unlock(lockKey);
        
        if(bIsRecord)
        {
            AOS_ASSERT(0);
            aos_printf(MPE_SYS,cStackOverFlowUp,cName,bp,ulStackSize);
            bIsRecord = FALSE;
        }
        
        return;
    }

    if(*(g_pstTask[ulTaskID].stack_bottom) != SPY_STACK_BOTTOM_VALUE)
    {
        dbg_dbg_info_cache_flush();
        aos_int_unlock(lockKey);

        if(bIsRecord)
        {
            AOS_ASSERT(0);
            aos_printf(MPE_SYS,cStackOverFlowDown,cName,bp,ulStackSize);
            bIsRecord = FALSE;
        }

        return;
    }

    aos_int_unlock(lockKey);

}

VOID ssp_add_task_switch_track( U32 sys_last_task, U32 sys_next_task )
{
    TSK_SW_TRACK_S * tsk_sw_trackp;
    U32              lockKey;

    lockKey = aos_int_lock();

    tsk_sw_trackp = &dbg_pool->dbg_info[dbg_pool->cur_dbg_index].tsk_sw_info;
        
    tsk_sw_trackp->last_tasks[tsk_sw_trackp->cur_index] = sys_last_task;
    aos_cputick_get(&tsk_sw_trackp->last_ticks[tsk_sw_trackp->cur_index]);
    aos_cputick_sub(&tsk_sw_trackp->last_ticks[tsk_sw_trackp->cur_index], &start_tick);
    tsk_sw_trackp->cur_count++;
    tsk_sw_trackp->cur_index++;
    if( CONFIG_TASK_SWITCH_TRACK_NUM == tsk_sw_trackp->cur_index )
    {
        tsk_sw_trackp->cur_index = 0;
    }
    tsk_sw_trackp->cur_task = sys_next_task;
    aos_cputick_get(&start_tick);

    aos_int_unlock( lockKey );
}


VOID ssp_get_os_task_name( U32 osTid, S8 tsk_name[9] )
{
#if( CONFIG_OS_VXWORKS == TRUE )    
    S8 *p;

    if( osTid )
    {
        p = (S8*)taskName(osTid);
        if( !p )
        {
            p = "Unknown";
        }
    }
    else
    {
        p = "T_ISR";
    }

    aos_strncpy( tsk_name, p , 8 );
    tsk_name[8] = 0;
#else
    aos_strcpy( tsk_name, "Unknown" );
#endif
}

VOID ssp_show_task_switch_track()
{
#if( CONFIG_OS_VXWORKS == TRUE )
    U32 idx, sec, usec;
    TSK_SW_TRACK_S * tsk_sw_trackp;
    S8      str_base[100], *str_buf;
    S32     offset, buf_len;
    S8      tsk_name[9];

    tsk_sw_trackp = &dbg_pool->dbg_info[dbg_pool->cur_dbg_index].tsk_sw_info;


    buf_len = 100;
    str_buf = str_base;
    ssp_get_os_task_name(tsk_sw_trackp->cur_task, tsk_name);
    offset = aos_snprintf( str_buf, (U32)buf_len, "SWITCH:%8s", tsk_name );

    buf_len -= offset;
    str_buf += offset;
    idx = tsk_sw_trackp->cur_index;
    if( 0 == idx )
    {
        idx = CONFIG_TASK_SWITCH_TRACK_NUM - 1;
    }
    else
    {
        idx--;
    }

    ssp_get_os_task_name(tsk_sw_trackp->last_tasks[idx], tsk_name);

    aos_cputick_2us( &tsk_sw_trackp->last_ticks[idx], &sec, &usec );
    offset = aos_snprintf( str_buf, (U32)buf_len, "<-%8s, elapsed time=(%us,%uus)",
                tsk_name, sec, usec );

    if( 0 == idx )
    {
        idx = CONFIG_TASK_SWITCH_TRACK_NUM - 1;
    }
    else
    {
        idx--;
    }
    ssp_get_os_task_name(tsk_sw_trackp->last_tasks[idx], tsk_name);
    buf_len -= offset;
    str_buf += offset;    
    aos_cputick_2us( &tsk_sw_trackp->last_ticks[idx], &sec, &usec );
    offset = aos_snprintf( str_buf, (U32)buf_len, "<-task=%9s, elapsed time=(%us,%uus)...",
                tsk_name, sec, usec );

    aos_printf( MPE_TASK, "%s", str_base );
#endif
}

U32 m_dbg_info_init()
{
#if( CONFIG_OS_VXWORKS == TRUE )

#if( CONFIG_BOARD_GMPU == TRUE || CONFIG_BOARD_GDSP == TRUE )
    dbg_pool = (DBG_POOL_S*)CONFIG_DEBUG_INFO_ADDR;
#else
    dbg_pool = (DBG_POOL_S*)sysMemTop();
#endif

#else
    dbg_pool = (DBG_POOL_S*)malloc(CONFIG_DEBUG_INFO_LEN);
    aos_memset( dbg_pool, 0, CONFIG_DEBUG_INFO_LEN );
#endif

#if( CONFIG_VERSION_DEBUG == TRUE )