ssp_cmd.c

abstract rtos

        return;
    }

}








U32 aos_smd_show_dmem_getsize(S8 *pszSize,U32 * pulMemSize)
{
    S32 lRet;
    U32 i;

    if((pszSize == NULL) || (pulMemSize == NULL))
    {
        return AOS_FAIL;
    }

    if(aos_strnicmp("all",pszSize,aos_strlen(pszSize)) != 0)
    {
        lRet = aos_atoul(pszSize, pulMemSize);
        if( AOS_SUCC != lRet )
        {
            return AOS_FAIL;
        }

        for(i = 0;i < CONFIG_MEM_BUF_NUM;i++)
        {
            if(g_pstMemBuf[i].status == FALSE)
            {
                continue;
            }

            if( *pulMemSize == (g_pstMemBuf[i].objsize-8) )
            {
                break;
            }
        }

        if( i >= CONFIG_MEM_BUF_NUM )
        {
            return AOS_FAIL;
        }
    }
    else
    {
        *pulMemSize = 0;
    }

    return AOS_SUCC;
}








U32 aos_smd_show_dmem_getmpe(S8 *pszMpe,U32 * pulMpe)
{
    S32 lRet;

    if((pszMpe == NULL) || (pulMpe == NULL))
    {
        return AOS_FAIL;
    }
    
    if(aos_strnicmp("all",pszMpe,aos_strlen(pszMpe)) != 0)
    {
        lRet = aos_atoul(pszMpe, pulMpe);
        if( AOS_SUCC != lRet )
        {
            return AOS_FAIL;
        }
    }
    else
    {
        *pulMpe = U32_BUTT;
    }

    return AOS_SUCC;
}









VOID aos_cmd_show_mem_obj (U32 argc,S8 * argv[])
{
    S32 lRet;
    U32 ulUserIndex, ulAddr;
    S8  *szCmdHelp = "\r\ncomand format:\r\nshow memory object address\r\n";
    S8  szBuf[256];
    STA_MEM_S  *pSmem;
    OBJ_CTRL_S *pObjCtrl;
    
     
    lRet = aos_atol(argv[0], (S32*)&ulUserIndex);
    if( AOS_SUCC != lRet )
    {
        cli_out_string(0,"\r\nget userindex error!!!\r\n");
        return;
    }
    
    
    if(argc != 3)
    {
        cli_out_string(ulUserIndex,szCmdHelp);
        return;
    }

    if(( 0 == aos_strncmp( "0x", argv[2], 2)) ||
       ( 0 == aos_strncmp( "0X", argv[2], 2)))
    {
        aos_atoulx( argv[2]+2, &ulAddr );
    }
    else
    {
        aos_atoul( argv[2], &ulAddr );
    }
    
    szBuf[255] = 0;
    if( ulAddr < ((U32)g_pPageOffset + MEM_PAGE_SIZE*g_ulPageNum) )
    {
        if( ulAddr >= g_ulStaticMemStart )
        {
            

            pSmem  = g_pstStaMemList;
            for( ;pSmem; )
            {
                if( RED_MAGIC1 != pSmem->magic_number )
                {
                    aos_snprintf( szBuf, 255, "\r\nstatic memory write overflow,addr=0x%x!!!\r\n", pSmem );
                    cli_out_string(ulUserIndex, szBuf );
                    break;
                }
                if( ulAddr >= (U32)pSmem->s_mem 
                 && ulAddr < (U32)&pSmem->s_mem[pSmem->len] )
                {
                    aos_snprintf( szBuf, 255, "\r\nMem Object Found, Addr=0x%x, Size=%u, Mpe=%u, Sid=%u, tick=%u\r\n",
                        pSmem->s_mem, pSmem->len, pSmem->mpe, pSmem->sid, pSmem->tick );
                    cli_out_string(ulUserIndex, szBuf );
                    return;
                }
                pSmem = pSmem->next;
            }

        }
        else if( ulAddr >= (U32)g_pPageOffset )
        {
            
            pObjCtrl = mem_obj_ctrl((VOID*)ulAddr);
            if( pObjCtrl)
            {
                aos_snprintf( szBuf, 255, "\r\nMem Object Found, Addr=0x%x, Size=%u, Mpe=%u, Sid=%u, Tick=%u\r\nRef=%u, File=%s, Line=%u\rn",
                    mem_obj_head((VOID*)ulAddr), mem_obj_size((VOID*)ulAddr), pObjCtrl->mpe, pObjCtrl->sid, pObjCtrl->tick,
                    pObjCtrl->ref, ssp_cmd_get_short_file_name(pObjCtrl->file), pObjCtrl->line );
                cli_out_string(ulUserIndex, szBuf );
                return;                
            }
        }
    }

    cli_out_string(ulUserIndex,"\r\naddress belongs to OS or invalid\r\n");
}










VOID aos_cmd_show_spy(U32 argc,S8 * argv[])
{
    
    U32 i,j,k;
    U32 lockKey;
    U32 ulUserIndex;
    S32 lRet;
    S8  szBuffer[1024];
    S8  szName[AOS_NAME_LEN+1];
    TASK_INFINITE_LOOP_ITEM_S *pItem;
    TASK_INFINITE_LOOP_TRACE_S *pTaskSwitchTraceBase;

    lRet = aos_atol(argv[0], (S32*)&ulUserIndex);
    if(lRet != AOS_SUCC)
    {
        cli_out_string(0,"\r\nshow spy:get userindex error!!!\r\n");
        return;
    }

    if(argc > 2)
    {
        cli_out_string(0,"\r\nshow spy:too many parameter!!!\r\n");
        return;
    }

    pTaskSwitchTraceBase = ssp_get_task_infinite_loop_cb_base();
    if( NULL == pTaskSwitchTraceBase )
    {
        cli_out_string(0,"\r\nno task switch trace information!!!\r\n");
        return;
    }

    lockKey = aos_int_lock();
    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';
        lRet = 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);
        cli_out_string(ulUserIndex,szBuffer);
        cli_out_string( ulUserIndex, "\r\nCall Stack:" );
        lRet = 0;
        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);
            }
        }
        
        cli_out_string( ulUserIndex, szBuffer );
        cli_out_string( ulUserIndex, "\r\nStack Content:" );

        lRet = 0;
        k    = pItem->m_ulSp;
        for(j = 0;j < EXCEPTION_STACK_SIZE-1;j++)
        {
            lRet += aos_sprintf(szBuffer+lRet,"\r\n0x%08x: %08x %08x",k,
                                pItem->m_aStack[j],
                                pItem->m_aStack[j+1]);
            k += 8;
            if((j>0) && ((j % 64) == 0))
            {
                lRet = 0;
                cli_out_string(ulUserIndex,szBuffer);
            }
        }
        
        cli_out_string(ulUserIndex,szBuffer);

        
    }
    aos_int_unlock(lockKey);
}









VOID aos_cmd_show_exception(U32 argc,S8 * argv[])
{
#if( CONFIG_OS_VXWORKS == TRUE )
    
    U32 i;
    U32 ulUserIndex;
    U32 ulIndex;
    S32 lRet;
    S8  szBuffer[2048];
    S8  szName[AOS_NAME_LEN+1];
    EXCEPTION_ITEM_S *pItem;

    lRet = aos_atol(argv[0], (S32*)&ulUserIndex);
    if(lRet != AOS_SUCC)
    {
        cli_out_string(0,"\r\nshow exception:get userindex error.\r\n");
        return;
    }

    if(argc > 3)
    {
        cli_out_string(0,"\r\nshow exception:too many parameter.\r\n");
        return;
    }

    if(g_pException->m_ulCounter == 0)
    {
        cli_out_string(ulUserIndex,"\r\nno exception.\r\n");
        return;
    }
    
    if(argc == 2)
    {
        ulIndex = g_pException->m_ulIndex;
    }
    else
    {
        lRet = aos_atoul(argv[2], &ulIndex);
        if(lRet != AOS_SUCC)
        {
            cli_out_string(ulUserIndex,"\r\nget index error.\r\n");
            return;
        }

        if(g_pException->m_ulCounter <= EXCEPTION_RECORD_NUM)
        {
            if(ulIndex > g_pException->m_ulIndex)
            {
                cli_out_string(ulUserIndex,"\r\nindex too big.\r\n");
                return;
            }
        }
        else
        {
            if(ulIndex >= EXCEPTION_RECORD_NUM)
            {
                cli_out_string(ulUserIndex,"\r\nindex too big.\r\n");
                return;
            }
        }
    }
    
    pItem = g_pException->m_aItem + ulIndex;
    

    for(i = 0;i < AOS_NAME_LEN;i++)
    {
        szName[i] = pItem->m_cTaskName[i];
    }
    szName[i] = '\0';
    
    lRet = aos_sprintf(szBuffer,
                       "\r\nexception:%d"
                       "\r\ntask:%s"
                       "\r\ntime:%d %d-%d-%d-%d"
                       "\r\npc:0x%x"
                       "\r\nsp:0x%x",
                       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);
    for(i = 0;i < EXCEPTION_STACK_LAYER;i++)
    {
        if(NULL != pItem->m_aStackLayer[i].stack_addr) 
        {
            lRet += aos_sprintf(szBuffer+lRet,
                                "\r\nstack addr:0x%08x,instruction addr:0x%08x",
                                pItem->m_aStackLayer[i].stack_addr,
                                pItem->m_aStackLayer[i].next_inst_addr);
        }
    }
    cli_out_string(ulUserIndex,szBuffer);

    
    {
        U32 * pReg;
        
        lRet = 0;
        pReg = (U32 *)&(pItem->m_aReg);
        for(i = 0;i < sizeof(struct reg_set)/sizeof(U32);i ++)
        {
            if((i % 2) == 0)
            {
                lRet += aos_sprintf(szBuffer+lRet,"\r\n");
            }

            if(*(pReg + i) != 0)
            {
                lRet += aos_sprintf(szBuffer+lRet,"reg:%-10s,value=0x%-8x ",
                                    g_aRegName[i],*(pReg+i));
            }
        }

        cli_out_string(ulUserIndex,szBuffer);
    }

    
    {
        U32  k;

        cli_out_string(ulUserIndex,"\r\nstack content:");
        
        lRet = 0;
        k    = pItem->m_ulSp;
        for(i = 0;i < EXCEPTION_STACK_SIZE-1;i += 2)
        {
            lRet += aos_sprintf(szBuffer+lRet,"\r\n0x%08x: %08x %08x",k,
                                pItem->m_aStack[i],
                                pItem->m_aStack[i+1]);
            k += 8;
            if((i>0) && ((i % 64) == 0))
            {
                lRet = 0;
                cli_out_string(ulUserIndex,szBuffer);
            }
        }
        
        cli_out_string(ulUserIndex,szBuffer);
    }
#endif    
}









VOID aos_cmd_show_performance(U32 argc,S8 * argv[])
{
    
    U32 ulUserIndex;
    S32 lRet;
    S8  szBuffer[512];
    U32 ulPerCur;
    U32 ulPer5s;
    U32 ulPer60s;
    U32 ulPer600s;

    lRet = aos_atol(argv[0], (S32*)&ulUserIndex);
    if(lRet != AOS_SUCC)
    {
        cli_out_string(0,"\r\nshow performance:get userindex error.\r\n");
        return;
    }

    if(argc > 2)
    {
        cli_out_string(0,"\r\nshow performance:too many parameter.\r\n");
        return;
    }

    aos_cpu_performance_get(&ulPerCur,&ulPer5s,&ulPer60s,&ulPer600s);

    aos_sprintf(szBuffer,"\r\n    performance now :%d "
                         "\r\n    performance 5s  :%d  "
                         "\r\n    performance 60s :%d "
                         "\r\n    performance 600s:%d ",
                         ulPerCur,
                         ulPer5s,
                         ulPer60s,
                         ulPer600s);

    cli_out_string(ulUserIndex,szBuffer);
}

S8 *ssp_cmd_get_short_file_name( S8 *file )
{
    S8 *pShortName;
    U32 nLen;

    
    nLen = aos_strnlen( file, 200 );
    if( nLen >= 200 || !nLen)
    {
        aos_sprintf( g_FileNameInAddr, "%-8x", file );
        return g_FileNameInAddr;
    }

    for( pShortName = file + nLen -1;
         (pShortName > file) && (FILE_SLASH != *pShortName);
         pShortName-- )
	;

    if( FILE_SLASH == *pShortName )
    {
        pShortName++;
    }
    return pShortName;

}

#endif

#ifdef __cplusplus
}
#endif