ssp_except_ppc.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"
#if( CONFIG_BOARD_GMPU == TRUE )
#include "db_pub.h"
#endif
#if (AOS_INCLUDE_SERVICE_SDFS_FTPS == TRUE)
#include "files_pub.h"
#endif

U32 g_ulLastExceptionTime = 0;
U32 g_ulContinousExceptionCnt = 0;


extern EXCEPTION_BUF_S *g_pException;
S8 g_aRegName[][10] = {"r0",
                       "r1",
                       "r2",
                       "r3",
                       "r4",
                       "r5",
                       "r6",
                       "r7",
                       "r8",
                       "r9",
                       "r10",
                       "r11",
                       "r12",
                       "r13",
                       "r14",
                       "r15",
                       "r16",
                       "r17",
                       "r18",
                       "r19",
                       "r20",
                       "r21",
                       "r22",
                       "r23",
                       "r24",
                       "r25",
                       "r26",
                       "r27",
                       "r28",
                       "r29",
                       "r30",
                       "r31",
                       "msr",
                       "lr",
                       "ctr",
                       "cr",
                       "xer",
                       "dar",
                       "dsisr",
                       "fpcsr"};

VOID ssp_except_handle(U32 ulTask,U32 ulVecNum,ESFPPC *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,ESFPPC *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;

    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*60) )
    {
        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 = pEsf->regSet.pc;
    pItem->m_ulSp = pEsf->regSet.gpr[1];

    
    sp = pItem->m_ulSp;
    bp = g_pstTask[ulTaskID].sys_task_id;
    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
    {
        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( sp < (U32)sysMemTop() )
        {
            sp = *(U32 *)sp;
            for ( ; (i< EXCEPTION_STACK_LAYER) && (sp != 0); i++ )
            {
                if( sp < ((U32)sysMemTop()-4) )
                {
                    pItem->m_aStackLayer[i].stack_addr     = sp;
                    pItem->m_aStackLayer[i].next_inst_addr = *(U32 *)(sp + 4);
                    sp = *(U32 *)sp;
                }
                else
                {
                    break;
                }
            }
        }

        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     = NULL;
            pItem->m_aStackLayer[i].next_inst_addr = NULL;
        }
    }

    
    for(i = 0;i < 32;i++)
    {
        pItem->m_aReg.gpr[i] = pEsf->regSet.gpr[i];
    }
    pItem->m_aReg.msr   = pEsf->regSet.msr;
    pItem->m_aReg.lr    = pEsf->regSet.lr;
    pItem->m_aReg.ctr   = pEsf->regSet.ctr;
    pItem->m_aReg.cr    = pEsf->regSet.cr;
    pItem->m_aReg.xer   = pEsf->regSet.xer;
    pItem->m_aReg.dar   = pEsf->dar;
    pItem->m_aReg.dsisr = pEsf->dsisr;
    pItem->m_aReg.fpcsr = pEsf->fpcsr;

#if( CONFIG_BOARD_GMPU == TRUE || CONFIG_BOARD_GDSP == TRUE )
    
    pItem->last_msg_ptr = dbg_get_last_msg_ptr(&pItem->msg_status, &pItem->last_msg_size);
    
    if( AOS_ADDR_VALID(pItem->last_msg_ptr) )
    {
        aos_memcpy( pItem->m_aLastMsg, (VOID*)pItem->last_msg_ptr, EXCEPTION_SAVE_MSG_LEN );
    }
    else
    {
        aos_memzero( pItem->m_aLastMsg, sizeof(pItem->m_aLastMsg) );
    }
#endif

    dbg_dbg_info_cache_flush();
    
    #if CONFIG_VERSION_DEBUG
    {
        
        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);

    }
    #endif

    

#if( CONFIG_BOARD_GMPU == TRUE )    
    
    if( g_ulContinousExceptionCnt < 2 )
    {
        if( AOS_SUCC == aos_task_restart(ulTaskID) )
        {
            return;
        }
    }
    
    if( !db_can_reset() )
    {
        goto restart_later;
    }
    if( flash_is_writing() )
    {
        goto restart_later;
    }
#if (AOS_INCLUDE_SERVICE_BILL == TRUE)
    if( bill_pool_bill_num() )
    {
        goto restart_later;
    }
#endif
#if (AOS_INCLUDE_SERVICE_SDFS_FTPS == TRUE)
	if( !files_can_reset() )
	{
		goto restart_later;				
	}
#endif  

#elif( CONFIG_BOARD_GDSP == TRUE )

#elif( CONFIG_BOARD_EIA == TRUE )
    if( flash_is_writing() )
    {
        goto restart_later;
    }
#else
    #error unknown product!!!
#endif

    drv_cpu_reset();

restart_later:
    if( U32_BUTT != g_ulSystemRestartTaskId )
    {
        aos_event_post( g_ulSystemRestartTaskId, 0x1 );
    }
}

#endif

#ifdef __cplusplus
}
#endif