ssp_except_mips.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif

#include "syscfg.h"
#if( AOS_INCLUDE_SSP_KER_EXCEPTION == TRUE )
#include "sys/sys_pub.h"
#include "aos.h"
#include "ssp_event.h"
#include "ssp_task.h"
#include "ssp_except.h"

U32 g_ulLastExceptionTime = 0;
U32 g_ulContinousExceptionCnt = 0;


extern EXCEPTION_BUF_S *g_pException;
S8 g_aRegName[][10] = {
                       "sr",
                       "pc",
                       "lo",
                       "hi",
                       "zero",
                       "at",
                       "v0",
                       "v1",
                       "a0",
                       "a1",
                       "a2",
                       "a3",
                       "t0",
                       "t1",
                       "t2",
                       "t3",
                       "t4",
                       "t5",
                       "t6",
                       "t7",
                       "s0",
                       "s1",
                       "s2",
                       "s3",
                       "s4",
                       "s5",
                       "s6",
                       "s7",
                       "t8",
                       "t9",
                       "k0",
                       "k1",
                       "gp",
                       "sp",
                       "fp",
                       "ra",
                       "cause",
                       "fpcsr"};

VOID ssp_except_handle(U32 ulTask,U32 ulVecNum,ESFMIPS *pEsf);
#if CONFIG_OS_VXWORKS
extern void dbg_dbg_info_cache_flush();
extern char * sysMemTop (void);
#endif

VOID ssp_except_handle(U32 ulTask,U32 ulVecNum,ESFMIPS *pEsf)
{
    U32 ulTaskID;
    U32 sp;
    U32 bp;
    U32 i;
    S8  cName[AOS_NAME_LEN+1];
    EXCEPTION_ITEM_S *pItem;
    SYS_TIME_S DateTime;
    U32        cur_sec,pc,instr,cnt,cnt_clear;
#if ( CONDIF_BIG_ENDIAN == FALSE )
    U32        ra_find,ra;
#endif    

    if(pEsf == NULL)
    {
        return;
    }

    ulTaskID = ssp_task_osidTOaosid(ulTask);
    if(ulTaskID == U32_BUTT)
    {
        return;
    }

    aos_time_get_sec( &cur_sec );

    
    if( (cur_sec - g_ulLastExceptionTime) <= 10 )
    {
        g_ulContinousExceptionCnt++;
    }
    else
    {
        g_ulContinousExceptionCnt = 0;
    }
    g_ulLastExceptionTime = cur_sec;


    
    g_pException->m_ulCounter ++;
    g_pException->m_ulIndex = (g_pException->m_ulIndex + 1) % EXCEPTION_RECORD_NUM;
    
    pItem = g_pException->m_aItem + g_pException->m_ulIndex;

    
    pItem->m_ulVecNum  = ulVecNum;
    pItem->m_ulErrorNo = 0;
    pItem->m_ulIntCount= (U32)intCount();

    
    for(i = 0;i < AOS_NAME_LEN;i++)
    {
        pItem->m_cTaskName[i] = g_pstTask[ulTaskID].name[i];
    }

    
    aos_time_get(&DateTime);
    pItem->m_uDate      = DateTime.date;
    pItem->m_uHour      = DateTime.hour;
    pItem->m_uMinute    = DateTime.minute;
    pItem->m_uSecond    = DateTime.second;
    pItem->m_ulMillisec = DateTime.millisec;

    
    pItem->m_ulPc = (U32)pEsf->esfRegs.pc;
    pItem->m_ulSp = pEsf->esfRegs.gpreg[29];

    
    sp = pItem->m_ulSp;
    bp = g_pstTask[ulTaskID].sys_task_id;
#if 0    
    if( bp < (U32)sysMemTop() )
    {
        for(i = 0;i < EXCEPTION_STACK_SIZE;i++)
        {
            if((sp + i) < bp)
            {
                pItem->m_aStack[i] = *(U32 *)(sp+i);
            }
            else
            {
                pItem->m_aStack[i] = 0;
            }
        }
    }
    
    else
#endif        
    {
        for(i = 0;i < EXCEPTION_STACK_SIZE;i++)
        {
            pItem->m_aStack[i] = 0xEE;
        }
    }

    
    i = 0;
    pItem->m_aStackLayer[0].stack_addr     = sp;
    pItem->m_aStackLayer[0].next_inst_addr = pItem->m_ulPc;
    i++;

#if ( CONDIF_BIG_ENDIAN == TRUE )
    pc = pEsf->esfRegs.gpreg[31]; 
    pItem->m_aStackLayer[i].stack_addr     = sp;
    pItem->m_aStackLayer[i].next_inst_addr = pc;
    i++;

    for ( ; i< EXCEPTION_STACK_LAYER; i++ )
    {
#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, "i=%u,function too big pc=0x%x,instr=0x%x!!!!", i,pc, instr );
            break;
        }
        pc -= 4;
        instr = *(U32*)pc;
        if( (instr & INSTR_MASK) != INSTR_SP_RESTORE )
        {
            aos_printf( 0, "i = %u,abnormal invoke,pc=0x%x,instr=0x%x!!!!",i, pc, instr );
            break;
        }

        sp += instr & INSTR_SP_MASK;

#undef INSTR_JR
#undef INSTR_SP_RESTORE
#undef INSTR_SP_MASK            
#undef INSTR_MASK

        if(sp > 0x80000000 && sp < bp
         && pc > 0x80000000)
        {
            pc = *(U32*)(sp-4);
            pItem->m_aStackLayer[i].stack_addr     = sp;
            pItem->m_aStackLayer[i].next_inst_addr = pc;
        }
        else
        {
            break;
        }
    }
#else
    pc = pItem->m_ulPc;
    for ( ; i< EXCEPTION_STACK_LAYER; i++ )
    {
        if( sp >= bp || 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
              && (S16)(instr & INSTR_SP_MASK) < 0 )
            {
                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, "i=%u, function too big!!!!cnt=%u,pc=0x%x,instr=0x%x",i,cnt,pc,instr );
            break;
        }
        if( !ra_find )
        {
            aos_printf( 0, "i=%u, abnormal invoke,can't find ra store instr!!!!,pc=0x%x,instr=0x%x",i,pc,instr );
            break;
        }

        pItem->m_aStackLayer[i].stack_addr     = sp;
        pItem->m_aStackLayer[i].next_inst_addr = ra;
        i++;

        sp += -(S16)(instr & INSTR_SP_MASK);
        pc = ra;
        if( pc > (U32)ssp_task_entry && pc < (U32)ssp_has_starve_task )
        {
            break;
        }

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

#endif

    if( i < EXCEPTION_STACK_LAYER )
    {
        pItem->m_aStackLayer[i].stack_addr     = sp;
        pItem->m_aStackLayer[i].next_inst_addr = 0xBAD00BAD;
        i++;
    }
    
    if( i < EXCEPTION_STACK_LAYER )
    {
        pItem->m_aStackLayer[i].stack_addr     = (U32)NULL;
        pItem->m_aStackLayer[i].next_inst_addr = (U32)NULL;
    }

    
    for(i = 0;i < 32;i++)
    {
        pItem->m_aReg.gpreg[i] = pEsf->esfRegs.gpreg[i];
    }

    pItem->m_aReg.sr    = pEsf->esfRegs.sr;
    pItem->m_aReg.pc    = pEsf->esfRegs.pc;  
    pItem->m_aReg.lo    = pEsf->esfRegs.lo;  
    pItem->m_aReg.hi    = pEsf->esfRegs.hi;  
    pItem->m_aReg.cause = pEsf->esfRegs.cause;
    pItem->m_aReg.fpcsr = pEsf->esfRegs.fpcsr;
    
    dbg_dbg_info_cache_flush();
    
    {
        
        for(i = 0;i < AOS_NAME_LEN;i++)
        {
            cName[i] = pItem->m_cTaskName[i];
        }
        cName[i] = '\0';
        aos_printf(MPE_SYS,"\r\nexception:0x%x"
                           "\r\ntask:%s"
                           "\r\npc=0x%x,sp=0x%x,bp=0x%x\r\n",
                           pItem->m_ulVecNum,
                           cName,
                           pItem->m_ulPc,
                           pItem->m_ulSp,
                           bp);

    }

#if( CONFIG_BOARD_EIA == TRUE )
    drv_cpu_reset();
#else
    #error unknown platform!!!
#endif
}

#endif

#ifdef __cplusplus
}
#endif