ssp_spy.c

abstract rtos

    g_ulEnableTrace = FALSE;
#else
    g_ulEnableTrace = FALSE;
#endif

#if( CONFIG_OS_VXWORKS == TRUE )
#if( CONFIG_BOARD_GMPU == TRUE )
    
    if( CONFIG_DEBUG_INFO_LEN < ( sizeof(DBG_POOL_S) + 8 + 16 )  )
    
#else
    if( ( (U32)(sysPhysMemTop()-sysMemTop())) < ( sizeof(DBG_POOL_S) + 8 )  )
#endif
    {
        printf( "\r\nAOS no debug buffer!!!\r\n" );
        return AOS_FAIL;
    }

#endif
    
    printf( "\r\nAOS debug buffer=0x%x size=0x%x\r\n",(U32)dbg_pool, sizeof(DBG_POOL_S)+8 );

    if(  DBG_MAGIC_NUM != dbg_pool->magic1
       ||DBG_MAGIC_NUM != dbg_pool->magic2 )
    {
        aos_memset( dbg_pool, 0, sizeof(DBG_POOL_S) );
        dbg_pool->magic1        = DBG_MAGIC_NUM;
        dbg_pool->cur_dbg_index = 0;
        dbg_pool->count         = 1;
        dbg_pool->cur_mini_system_flag1 = 0;
        dbg_pool->cur_mini_system_flag2 = 0;
        dbg_pool->next_syetem_flag1      = AOS_MINI_SYSTEM_FLAG;
        dbg_pool->next_syetem_flag2      = AOS_MINI_SYSTEM_FLAG;
        dbg_pool->min_start_count        = 0;
        dbg_pool->magic2        = DBG_MAGIC_NUM;
    }
    else
    {
        dbg_pool->cur_dbg_index++;

#if( CONFIG_BOARD_GMPU == TRUE || CONFIG_BOARD_GDSP == TRUE )    
        dbg_pool->cur_dbg_index &= 3;
#else
        dbg_pool->cur_dbg_index &= 1;
#endif
        dbg_pool->count++;
        if( AOS_MINI_SYSTEM_FLAG == dbg_pool->next_syetem_flag1
         && AOS_MINI_SYSTEM_FLAG == dbg_pool->next_syetem_flag2 )
        {
            dbg_pool->min_start_count++;
        }
        else
        {
            dbg_pool->min_start_count        = 0;
        }

        if( dbg_pool->min_start_count >= 3 )
        {
            dbg_pool->cur_mini_system_flag1 = AOS_MINI_SYSTEM_FLAG;
            dbg_pool->cur_mini_system_flag2 = AOS_MINI_SYSTEM_FLAG;
            dbg_pool->next_syetem_flag1      = 0;
            dbg_pool->next_syetem_flag2      = 0;
            dbg_pool->min_start_count        = 0;
        }
        else
        {
            dbg_pool->cur_mini_system_flag1 = 0;
            dbg_pool->cur_mini_system_flag2 = 0;
            dbg_pool->next_syetem_flag1      = AOS_MINI_SYSTEM_FLAG;
            dbg_pool->next_syetem_flag2      = AOS_MINI_SYSTEM_FLAG;
        }

        aos_memset( &dbg_pool->dbg_info[dbg_pool->cur_dbg_index], 0, sizeof(DBG_INFO_S) );
    }
    g_pException = &dbg_pool->dbg_info[dbg_pool->cur_dbg_index].exc_info;
    m_ulTraceSn = 0;

#if( CONFIG_BOARD_GMPU == TRUE )
    
    if( 0 == aos_strcmp( (S8*)DBG_SOFTWARE_RESET_MAGIC_ADDR, DBG_SOFTWARE_RESET_MAGIC_STR ) )
    {
        g_ulIsSoftwareResetLastTime = 1;
    }
    else
    {
        g_ulIsSoftwareResetLastTime = 0;
    }
    aos_memset( (VOID*)DBG_SOFTWARE_RESET_MAGIC_ADDR, 0, 16 );
#endif
    
    
    return AOS_SUCC;
}

U32 aos_is_mini_system()
{

#if( CONFIG_BOARD_GMPU == TRUE )
    if( AOS_MINI_SYSTEM_FLAG == dbg_pool->cur_mini_system_flag1
    || AOS_MINI_SYSTEM_FLAG == dbg_pool->cur_mini_system_flag2 )
    {
        return 1;
    }
#endif

    return 0;
}

U32 aos_set_mini_system_flag4next()
{
    dbg_pool->next_syetem_flag1 = AOS_MINI_SYSTEM_FLAG;
    dbg_pool->next_syetem_flag2 = AOS_MINI_SYSTEM_FLAG;
    dbg_pool->min_start_count   = 3;
    return 0;
}

U32 aos_clear_mini_system_flag4next()
{
    dbg_pool->next_syetem_flag1 = 0;
    dbg_pool->next_syetem_flag2 = 0;
    dbg_pool->min_start_count   = 0;
    return 0;
}

BOOL_T aos_is_boot_with_lost_power(VOID)
{
    return g_ulIsSoftwareResetLastTime ? FALSE : TRUE;
}

VOID aos_set_software_reset_flag(VOID)
{
#if( CONFIG_BOARD_GMPU == TRUE )
    aos_strcpy( (S8*)DBG_SOFTWARE_RESET_MAGIC_ADDR, DBG_SOFTWARE_RESET_MAGIC_STR );
#endif
}

VOID dbg_track_msg_in(VOID* msgp)
{
    VOID *last_msgp;

    dbg_pool->dbg_info[dbg_pool->cur_dbg_index].last_msg_ptr = (U32)msgp;
    *(U32*)&dbg_pool->dbg_info[dbg_pool->cur_dbg_index].last_msg[0] = MSG_IN;
    last_msgp = (VOID*)&dbg_pool->dbg_info[dbg_pool->cur_dbg_index].last_msg[4];
    aos_memcpy( last_msgp, msgp, DBG_MAX_MSG_LEN );
}

VOID dbg_track_msg_out( )
{
    *(U32*)&dbg_pool->dbg_info[dbg_pool->cur_dbg_index].last_msg[0] = MSG_OUT;
}

U32 dbg_get_last_msg_ptr( U32 *status, U32 *size )
{
    *status = *(U32*)&dbg_pool->dbg_info[dbg_pool->cur_dbg_index].last_msg[0];
    *size   = ((L3_MSG_HEAD_S*)&dbg_pool->dbg_info[dbg_pool->cur_dbg_index].last_msg[4])->ulSize;

    return dbg_pool->dbg_info[dbg_pool->cur_dbg_index].last_msg_ptr;
}

VOID dbg_track_assert( S8 *cond, S8*file, U32 line )
{
    ASSERT_INFO_S *assert_infop;
    ASSERT_ITEM_S *assert_itemp;
    
    assert_infop = &dbg_pool->dbg_info[dbg_pool->cur_dbg_index].assert_info;
    assert_itemp = &assert_infop->assert_item[assert_infop->cur_index];

    aos_time_get( &assert_itemp->tm );
    aos_snprintf( assert_itemp->assert_str, 199, 
        "Assert:cond=%s,file=%s,line=%d", cond, file, line  );
    assert_itemp->assert_str[199] = 0;

    assert_infop->count++;
    assert_infop->cur_index++;
    if(assert_infop->cur_index >= DBG_MAX_ASSERT_NUM)
    {
        assert_infop->cur_index = 0;
    }

}

VOID dbg_track_run_flow( S8 *fmt, ... )
{
    VA_LIST argptr;
    S32     offset;
    
#define print_buf dbg_pool->dbg_info[dbg_pool->cur_dbg_index].run_track

    offset = aos_snprintf( (print_buf), DBG_MAX_TRACK_LEN, "[TRACK AT %d TICK]",aos_tick_get() );

    if( offset < DBG_MAX_TRACK_LEN )
    {
	    VA_START( argptr, fmt );
	    
	    offset +=aos_vsnprintf(&print_buf[offset], (U32)(DBG_MAX_TRACK_LEN-offset), fmt, argptr );
	    VA_END( argptr );
    }
    print_buf[offset] = '\0';
    
#undef print_buf    
}

VOID dbg_track_tick_state( U32 state )
{
#if( CONFIG_BOARD_GMPU == TRUE || CONFIG_BOARD_GDSP == TRUE )
    if( dbg_pool->cur_dbg_index < 4 )
#else
    if( dbg_pool->cur_dbg_index < 2 )
#endif
    {
        dbg_pool->dbg_info[dbg_pool->cur_dbg_index].tick_is_handling = state;
    }
}

#if( CONFIG_BOARD_GMPU == TRUE || CONFIG_BOARD_GDSP == TRUE )
DBG_INFO_S *dbg_get_dbg_info( U32 dbg_index )
{
    if( 0 == dbg_index )
    {
        
        return &dbg_pool->dbg_info[dbg_pool->cur_dbg_index];
    }
    else if( dbg_index > 3 )
    {
        return NULL;
    }

    if( 1 >= dbg_pool->count )
    {
        return NULL;
    }
    else
    {
        if( 1 == dbg_index )
        {
            return &dbg_pool->dbg_info[(dbg_pool->cur_dbg_index+3)&3];
        }
        else if( 2 == dbg_index )
        {
            if( 2 >= dbg_pool->count )
            {
                return NULL;
            }
            else
            {
                return &dbg_pool->dbg_info[(dbg_pool->cur_dbg_index+2)&3];
            }
        }
        else
        {
            if( 3 >= dbg_pool->count )
            {
                return NULL;
            }
            else
            {
                return &dbg_pool->dbg_info[(dbg_pool->cur_dbg_index+1)&3];
            }
        }
    }
}
#else
DBG_INFO_S *dbg_get_dbg_info( U32 dbg_index )
{
    if( 0 == dbg_index )
    {
        
        return &dbg_pool->dbg_info[dbg_pool->cur_dbg_index];
    }
    else if( dbg_index > 1 )
    {
        return NULL;
    }

    
    if( 1 >= dbg_pool->count )
    {
        return NULL;
    }

    if( 0 == dbg_pool->cur_dbg_index )
    {
        return &dbg_pool->dbg_info[1];
    }
    else
    {
        return &dbg_pool->dbg_info[0];        
    }
}
#endif
VOID dbg_show_exc_info( U32 dbg_index )
{
    DBG_INFO_S      *dbg_infop;
    EXCEPTION_BUF_S *exc_infop;
    U32             i;

    aos_printf( MPE_DEBUG, "show exception" );
    
    dbg_infop = dbg_get_dbg_info( dbg_index );
    if( NULL == dbg_infop )
    {
        return;
    }
    exc_infop = &dbg_infop->exc_info;
    if( exc_infop->m_ulCounter >= EXCEPTION_RECORD_NUM )
    {
        for( i = exc_infop->m_ulIndex+1; i < EXCEPTION_RECORD_NUM; i++ )
        {
            dbg_show_exc_item( &exc_infop->m_aItem[i] );
        }
    }

    if( exc_infop->m_ulIndex >= EXCEPTION_RECORD_NUM )
    {
        return;
    }

    if( exc_infop->m_ulCounter )
    {
	    for( i = 0; i <= exc_infop->m_ulIndex; i++ )
	    {
	        dbg_show_exc_item( &exc_infop->m_aItem[i] );
	    }
    }
}

VOID dbg_show_exc_item(  EXCEPTION_ITEM_S *pItem )
{
#if( CONFIG_OS_VXWORKS == TRUE )
    U32              i;
    S8               szBuffer[1024];
    S8               szName[AOS_NAME_LEN+4];
    S32              lRet;

    if( NULL == pItem )
    {
        return;
    }

    for(i = 0;i < AOS_NAME_LEN;i++)
    {
        szName[i] = pItem->m_cTaskName[i];
    }
    szName[i] = '\0';

    lRet = aos_sprintf(szBuffer,
                       "\r\nexception:0x%x"
                       "\r\ntask:%s"
                       "\r\ntime:%d %d-%d-%d-%d"
                       "\r\npc:0x%x"
                       "\r\nsp:0x%x"
                       "\r\nintCount:%u",
                       pItem->m_ulVecNum,
                       szName,
                       pItem->m_uDate,
                       pItem->m_uHour,
                       pItem->m_uMinute,
                       pItem->m_uSecond,
                       pItem->m_ulMillisec,
                       pItem->m_ulPc,
                       pItem->m_ulSp,
                       pItem->m_ulIntCount);
    
    for(i = 0;i < EXCEPTION_STACK_LAYER;i++)
    {
        if(NULL != pItem->m_aStackLayer[i].stack_addr) 
        {
            lRet += aos_sprintf(szBuffer+lRet,
                                "\r\nsp:0x%08x,instr:0x%08x",
                                pItem->m_aStackLayer[i].stack_addr,
                                pItem->m_aStackLayer[i].next_inst_addr);
        }
    }
    aos_printf( MPE_DEBUG,"%s", szBuffer );

    
    {
        U32 * pReg;
        U32 j = 0;
        
        lRet = 0;
        j     = 0;
        szBuffer[0] = 0;
        pReg = (U32 *)&(pItem->m_aReg);
        for(i = 0;i < sizeof(struct reg_set)/sizeof(U32);i ++)
        {
            lRet += aos_sprintf(szBuffer+lRet,"reg:%-5s,value=0x%-8x ",
                                   g_aRegName[i],*(pReg+i));
            j++;
            if( j >= 4 )
            {
    	        aos_printf( MPE_DEBUG,"\r\n%s", szBuffer );
    	        lRet = 0;
    	        j     = 0;
    	        szBuffer[0] = 0;
            }
        }
        if( j )
        {
            aos_printf( MPE_DEBUG,"\r\n%s", szBuffer );
        }
    }

    
    debug_mem_show( MPE_DEBUG, (U32)pItem->m_aStack, EXCEPTION_STACK_SIZE );

#if( CONFIG_BOARD_GMPU == TRUE || CONFIG_BOARD_GDSP == TRUE )
{
    L3_MSG_HEAD_S  *l3_msgp;
    U32            size;

    
    l3_msgp = (L3_MSG_HEAD_S*)&pItem->m_aLastMsg[0];
    if( MSG_IN == pItem->msg_status )
    {
        aos_printf( MPE_DEBUG, "last message(0x%x) is handling,srcProc=%d,srcMpe=%d,dstProc=%d,dstMpe=%d,size=%u,body at 0x%x ...",
            pItem->last_msg_ptr, l3_msgp->srcProcessorId, l3_msgp->srcMpe, l3_msgp->dstProcessorId, l3_msgp->dstMpe, l3_msgp->ulSize, l3_msgp->msg );
        
    }
    else if( MSG_OUT == pItem->msg_status )
    {
        aos_printf( MPE_DEBUG, "last message(0x%x) has handled,srcProc=%d,srcMpe=%d,dstProc=%d,dstMpe=%d,size=%u,body at 0x%x ...",
            pItem->last_msg_ptr, l3_msgp->srcProcessorId, l3_msgp->srcMpe, l3_msgp->dstProcessorId, l3_msgp->dstMpe, l3_msgp->ulSize, l3_msgp->msg );
    }
    else
    {
        return;
    }
    
    if( NULL != pItem->last_msg_ptr )
    {
        size = pItem->last_msg_size;
        if( size > 1024 )
        {
            size = 1024;
        }
        for( i = 0; i < size / 256; i++ )
        {
            debug_mem_show( MPE_DEBUG, (U32)&l3_msgp->msg[i*256], 256 );
        }
        if(size % 256)
        {
            debug_mem_show( MPE_DEBUG, (U32)&l3_msgp->msg[i*256],size % 256  );
        }
    }
}
#endif
    
#endif    
}

VOID dbg_show_tsk_sw_info( U32 dbg_index )
{
    TSK_SW_TRACK_S *tsk_sw_trackp;
    DBG_INFO_S     *dbg_infop;
    U32            i, sec, usec;
    S8             tsk_name[9];

    aos_printf( MPE_DEBUG, "show task switch track" );
    
    dbg_infop = dbg_get_dbg_info( dbg_index );
    if( NULL == dbg_infop )
    {
        return;
    }
    tsk_sw_trackp = &dbg_infop->tsk_sw_info;
    if( tsk_sw_trackp->cur_count >= CONFIG_TASK_SWITCH_TRACK_NUM )
    {
        for( i = tsk_sw_trackp->cur_index; i < CONFIG_TASK_SWITCH_TRACK_NUM; i++ )
        {
            ssp_get_os_task_name(tsk_sw_trackp->last_tasks[i], tsk_name);
            aos_cputick_2us( &tsk_sw_trackp->last_ticks[i], &sec, &usec );
            aos_printf( MPE_DEBUG, "SWITCH TRACK %d ,id=0x%08x, %8s, elapsed time=(%us,%uus)",
                        i, tsk_sw_trackp->last_tasks[i], tsk_name, sec, usec );
        }
    }

    if(tsk_sw_trackp->cur_index >= CONFIG_TASK_SWITCH_TRACK_NUM)
    {
        return;
    }

    for( i = 0; i < tsk_sw_trackp->cur_index; i++ )
    {
            ssp_get_os_task_name(tsk_sw_trackp->last_tasks[i], tsk_name);
            aos_cputick_2us( &tsk_sw_trackp->last_ticks[i], &sec, &usec );
            aos_printf( MPE_DEBUG, "SWITCH TRACK %d ,id=0x%08x, %8s, elapsed time=(%us,%uus)",
                        i, tsk_sw_trackp->last_tasks[i], tsk_name, sec, usec );
    }
    ssp_get_os_task_name(tsk_sw_trackp->cur_task, tsk_name);
    aos_printf( MPE_DEBUG, "Curret task is     0x%08x, %8s", tsk_sw_trackp->cur_task, tsk_name );
    aos_printf( MPE_DEBUG, "Tick task handling state is %u", dbg_infop->tick_is_handling );
}

VOID dbg_show_infinite_loop_info( U32 dbg_index )
{
    U32 i,j,k;
    S8  szBuffer[2048];
    S8  szName[AOS_NAME_LEN+1];
    TASK_INFINITE_LOOP_ITEM_S *pItem;
    TASK_INFINITE_LOOP_TRACE_S *pTaskSwitchTraceBase;
    DBG_INFO_S                  *dbg_infop;
    S32 lRet;

    aos_printf( MPE_DEBUG, "show infinite loop" );

    dbg_infop = dbg_get_dbg_info( dbg_index );
    if( NULL == dbg_infop )
    {
        return;
    }

    pTaskSwitchTraceBase = &dbg_infop->infinite_loop_task;

    for(i = 0;i < SPY_TASK_NUM;i++)
    {
        pItem = pTaskSwitchTraceBase->m_aItem + i;
        if(pItem->m_ulPowerOn == 0)
        {
            continue;
        }

        for(j = 0;j < AOS_NAME_LEN;j++)
        {
            szName[j] = pItem->m_cName[j];
        }
        szName[j] = '\0';
        aos_sprintf(szBuffer,
                   "\r\ntask:%s"
                   "\r\nmax ticks:%d"
                   "\r\nloops:%d"
                   "\r\nlast ticks:%d"
                   "\r\ntime:%d %d-%d-%d-%d",
                   szName,
                   pItem->m_ulMaxTick,
                   pItem->m_ulLoop,
                   pItem->m_ulRunTick,
                   pItem->m_uDate,
                   pItem->m_uHour,
                   pItem->m_uMinute,
                   pItem->m_uSecond,
                   pItem->m_ulMillisec);