bkendlog.c

vxworks源码源码解读是学习vxworks的最佳途径

    )
    {
    fprintf (wdbLogFile,"WDB_CTX_STEP_DESC\n");

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbContext (&pWdbCtxStep->context);

    fprintf (wdbLogFile,"\t\tstartAddr\t0x%x\n",(int) pWdbCtxStep->startAddr);
    fprintf (wdbLogFile,"\t\tendAddr\t\t0x%x\n",(int) pWdbCtxStep->endAddr);
    }

/*******************************************************************************
*
* bkendLogWdbCtxCreateDesc - log a WDB_CTX_CREATE_DESC structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbCtxCreateDesc
    (
    WDB_CTX_CREATE_DESC * pWdbCtxCreate         /* WDB_CTX_CREATE_DESC to log */
    )
    {
    int ix;                                     /* argument counter */

    fprintf (wdbLogFile,"WDB_CTX_CREATE_DESC\n");

    fprintf (wdbLogFile,"\t\tstackBase\t0x%x\n",(int) pWdbCtxCreate->stackBase);
    fprintf (wdbLogFile,"\t\tstackSize\t0x%x\n", pWdbCtxCreate->stackSize);
    fprintf (wdbLogFile,"\t\tentry\t\t0x%x\n",
             (int) pWdbCtxCreate->entry);

    for (ix =0; ix < 10 ; ix++)
        fprintf (wdbLogFile,"\t\targs[%d]\t\t%d\n", ix,
                                        (int) pWdbCtxCreate->args[ix]);

    if (pWdbCtxCreate->name == NULL)
        fprintf (wdbLogFile,"\t\tname\t\t%s\n", "NULL");
    else
        fprintf (wdbLogFile,"\t\tname\t\t%s\n", pWdbCtxCreate->name);

    fprintf (wdbLogFile,"\t\tpriority\t%d\n",(int) pWdbCtxCreate->priority);
    fprintf (wdbLogFile,"\t\toptions\t\t0x%x\n",(int) pWdbCtxCreate->options);
    fprintf (wdbLogFile,"\t\tredirIn\t\t%d\n",(int) pWdbCtxCreate->redirIn);
    fprintf (wdbLogFile,"\t\tredirOut\t%d\n",(int) pWdbCtxCreate->redirOut);
    fprintf (wdbLogFile,"\t\tredirErr\t%d\n",(int) pWdbCtxCreate->redirErr);
    }

/*******************************************************************************
*
* bkendLogWdbRegReadDesc - log a WDB_REG_READ_DESC structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbRegReadDesc
    (
    WDB_REG_READ_DESC * pWdbRegRead     /* WDB_REG_READ_DESC structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_REG_READ_DESC\n");

    fprintf (wdbLogFile,"\t\tregSetType\t"); 
    bkendLogWdbEnumToString ("REG_SET_TYPE", pWdbRegRead->regSetType);
    fprintf (wdbLogFile,"\n");

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbContext (&pWdbRegRead->context);

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbMemRegion (&pWdbRegRead->memRegion);
    }

/*******************************************************************************
*
* bkendLogWdbRegWriteDesc - log a WDB_REG_WRITE_DESC structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbRegWriteDesc
    (
    WDB_REG_WRITE_DESC * pWdbRegWrite   /* WDB_REG_WRITE_DESC struture to log */
    )
    {
    fprintf (wdbLogFile,"WDB_REG_WRITE_DESC\n");

    fprintf (wdbLogFile,"\t\tregSetType\t");
    bkendLogWdbEnumToString ("REG_SET_TYPE", pWdbRegWrite->regSetType);
    fprintf (wdbLogFile,"\n");

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbContext (&pWdbRegWrite->context);

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbMemXfer (&pWdbRegWrite->memXfer);
    }

/*******************************************************************************
*
* bkendLogWdbRtInfo - log a WDB_RT_INFO structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbRtInfo
    (
    WDB_RT_INFO *       pWdbRtInfo      /* WDB_RT_INFO structure to log */
    )
    {
    int         ix;                     /* WDB_MEM_REGION counter */

    fprintf (wdbLogFile,"WDB_RT_INFO\n");

    fprintf (wdbLogFile,"\t\trtType\t\t");
    bkendLogWdbEnumToString ("RT_TYPE", pWdbRtInfo->rtType);
    fprintf (wdbLogFile,"\n");

    if (pWdbRtInfo->rtVersion == NULL)
        fprintf (wdbLogFile,"\t\trtVersion\t%s\n", "Unknown");
    else
        fprintf (wdbLogFile,"\t\trtVersion\t%s\n", pWdbRtInfo->rtVersion);

    fprintf (wdbLogFile,"\t\tcpuType\t\t%d\n",(int) pWdbRtInfo->cpuType);
    fprintf (wdbLogFile,"\t\thasFpp\t\t%d\n", pWdbRtInfo->hasFpp);
    fprintf (wdbLogFile,"\t\thasWriteProtect\t%d\n", 
             pWdbRtInfo->hasWriteProtect);
    fprintf (wdbLogFile,"\t\tpageSize\t%d\n",(int) pWdbRtInfo->pageSize);
    fprintf (wdbLogFile,"\t\tendian\t\t%d\n",(int) pWdbRtInfo->endian);

    if (pWdbRtInfo->bspName == NULL)
        fprintf (wdbLogFile,"\t\tbspName\t\t%s\n", "Unknown");
    else
        fprintf (wdbLogFile,"\t\tbspName\t\t%s\n", pWdbRtInfo->bspName);

    if (pWdbRtInfo->bootline == NULL)
        fprintf (wdbLogFile,"\t\tbootline\t%s\n", "Unknown");
    else
        fprintf (wdbLogFile,"\t\tbootline\t%s\n", pWdbRtInfo->bootline);

    fprintf (wdbLogFile,"\t\tmemBase\t\t0x%x\n",(int) pWdbRtInfo->memBase);
    fprintf (wdbLogFile,"\t\tmemSize\t\t0x%x\n", pWdbRtInfo->memSize);
    fprintf (wdbLogFile,"\t\tnumRegions\t%d\n",(int) pWdbRtInfo->numRegions);

    for (ix = 0; ix < pWdbRtInfo->numRegions; ix++)
        {
        fprintf (wdbLogFile,"\t\t");
        bkendLogWdbMemRegion (&pWdbRtInfo->memRegion[ix]);
        }

    fprintf (wdbLogFile,"\t\thostPoolBase\t0x%x\n",
             (int) pWdbRtInfo->hostPoolBase);
    fprintf (wdbLogFile,"\t\thostPoolSize\t0x%x\n", 
             pWdbRtInfo->hostPoolSize);
    }

/*******************************************************************************
*
* bkendLogWdbAgentInfo - log a WDB_AGENT_INFO structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbAgentInfo
    (
    WDB_AGENT_INFO *    pWdbAgentInfo   /* WDB_AGENT_INFO structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_AGENT_INFO\n");

    if (pWdbAgentInfo->agentVersion == NULL)
        fprintf (wdbLogFile,"\t\tagentVersion\t%s\n", "Unknown");
    else
        fprintf (wdbLogFile,"\t\tagentVersion\t%s\n", 
                                                pWdbAgentInfo->agentVersion);

    fprintf (wdbLogFile,"\t\tmtu\t\t%d\n",(int) pWdbAgentInfo->mtu);
    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbAgentMode (&pWdbAgentInfo->mode);
    }

/*******************************************************************************
*
* bkendLogWdbTgtInfo - log a WDB_TGT_INFO structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbTgtInfo
    (
    WDB_TGT_INFO *      pWdbTgtInfo     /* WDB_TGT_INFO structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_TGT_INFO\n");

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbAgentInfo (&pWdbTgtInfo->agentInfo);

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbRtInfo (&pWdbTgtInfo->rtInfo);
    }

/*******************************************************************************
*
* bkendLogWdbAction - log a WDB_ACTION structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbAction
    (
    WDB_ACTION *        pWdbAction      /* WDB_ACTION structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_ACTION\n");
    fprintf (wdbLogFile ,"\t\tactionType\t");
    bkendLogWdbEnumToString ("ACTION_TYPE", pWdbAction->actionType);
    fprintf (wdbLogFile,"\n");
    fprintf (wdbLogFile,"\t\tactionArg\t%d\n", pWdbAction->actionArg);
    fprintf (wdbLogFile,"\t\tcallRtn\t\t%d\n",(int) pWdbAction->callRtn);
    fprintf (wdbLogFile,"\t\tcallArg\t\t%d\n",(int) pWdbAction->callArg);
    }

/*******************************************************************************
*
* bkendLogWdbEvtptAddDesc - log an WDB_EVTPT_ADD_DESC structure 
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbEvtptAddDesc 
    (
    WDB_EVTPT_ADD_DESC *        pWdbEvtptAdd    /* WDB_EVTPT_ADD_DESC to log */ 
    )
    {
    int         ix;                     /* argument counter */

    fprintf (wdbLogFile,"WDB_EVTPT_ADD_DESC\n");

    fprintf (wdbLogFile, "\t\tevtType\t\t");
    bkendLogWdbEnumToString ("EVENT_TYPE",pWdbEvtptAdd->evtType);
    fprintf (wdbLogFile,"\n");

    fprintf (wdbLogFile,"\t\tnumArgs\t\t%d\n",(int) pWdbEvtptAdd->numArgs);

    for (ix = 0; ix < pWdbEvtptAdd->numArgs; ix++)
        fprintf (wdbLogFile,"\t\targs[%d]\t\t0x%x\n", ix,
                                                pWdbEvtptAdd->args[ix]);

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbContext (&pWdbEvtptAdd->context);

    fprintf (wdbLogFile,"\t\t");
    bkendLogWdbAction (&pWdbEvtptAdd->action);
    }

/*******************************************************************************
*
* bkendLogWdbEvtptDelDesc - log an WDB_EVTPT_DEL_DESC structure 
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbEvtptDelDesc 
    (
    WDB_EVTPT_DEL_DESC * pWdbEvtptDel   /* WDB_EVTPT_DEL_DESC struture to log */
    )
    {
    fprintf (wdbLogFile,"WDB_EVTPT_DEL_DESC\n");

    fprintf (wdbLogFile, "\t\tevtType\t\t");
    bkendLogWdbEnumToString ("EVENT_TYPE",pWdbEvtptDel->evtType);
    fprintf (wdbLogFile,"\n");
    fprintf (wdbLogFile,"\t\tevtptId\t\t0x%x\n",(int) pWdbEvtptDel->evtptId);
    }

/*******************************************************************************
*
* bkendLogWdbEvtData - log a WDB_EVT_DATA structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbEvtData
    (
    WDB_EVT_DATA *      pWdbEvtData     /* WDB_EVT_DATA structure to log */
    )
    {
    void (*pEvntInfoFct) ();

    fprintf (wdbLogFile,"WDB_EVT_DATA\n");

    fprintf (wdbLogFile, "\t\tevtType\t\t");
    bkendLogWdbEnumToString ("EVENT_TYPE",pWdbEvtData->evtType);
    fprintf (wdbLogFile,"\n");

    switch (pWdbEvtData->evtType)
        {
        case WDB_EVT_NONE:              /* no event */ 
            pEvntInfoFct = NULL;
            break;

        case WDB_EVT_CTX_START:         /* context creation event */
            pEvntInfoFct = bkendLogWdbCtxStartInfo;
            break;

        case WDB_EVT_CTX_EXIT:          /* context exit event */
            pEvntInfoFct = bkendLogWdbCtxExitInfo;
            break;

        case WDB_EVT_BP:		/* breakpoint event */
            pEvntInfoFct = bkendLogWdbBpInfo;
            break;

        case WDB_EVT_WP:		/* watchpoint event */
            pEvntInfoFct = bkendLogWdbBpInfo;
            break;

        case WDB_EVT_EXC:		/* exception event */
            pEvntInfoFct = bkendLogWdbExcInfo;
            break;

        case WDB_EVT_VIO_WRITE:		/* virtual I/O write event */
            pEvntInfoFct = bkendLogWdbMemXfer;
            break;

        case WDB_EVT_CALL_RET:		/* function call finished event */
            pEvntInfoFct = bkendLogWdbCallRetInfo;
            break;

        case WDB_EVT_TSFS_OP:		/* VIO II operation */
            pEvntInfoFct = bkendLogWdbTsfsInfo;
            break;

        case WDB_EVT_USER:		/* user event */
            pEvntInfoFct = bkendLogWdbMemXfer;
            break;

        default :
            pEvntInfoFct = NULL;        
            break;
        }

    if (pEvntInfoFct != NULL)
        {
        fprintf (wdbLogFile,"\t\t");
        pEvntInfoFct (&pWdbEvtData->eventInfo.evtInfo);
        }
    }

/*******************************************************************************
*
* bkendLogWdbCallRetInfo - lod a WDB_CALL_RET_INFO structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbCallRetInfo
    (
    WDB_CALL_RET_INFO * pCallRetInfo    /* WDB_CALL_RET_INFO structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_CALL_RET_INFO\n");

    fprintf (wdbLogFile,"\t\tcallId\t\t0x%x\n", pCallRetInfo->callId);

    fprintf (wdbLogFile,"\t\treturnType\t");
    bkendLogWdbEnumToString ("RETURN_TYPE", pCallRetInfo->returnType);
    fprintf (wdbLogFile,"\n");

    switch (pCallRetInfo->returnType)
        {
        case WDB_CALL_RET_INT:
            fprintf (wdbLogFile,"\t\treturnValInt\t%d\n", (u_int)
                                        pCallRetInfo->returnVal.returnValInt);
            break;

        case WDB_CALL_RET_DBL:
            fprintf (wdbLogFile, "\t\treturnValDbl\t%f\n",
                                        pCallRetInfo->returnVal.returnValDbl);
            break;
        }

    fprintf (wdbLogFile,"\t\terrnoVal\t0x%x\n",(u_int) pCallRetInfo->errnoVal);
    }


/*******************************************************************************
*
* bkendLogWdbExcInfo - log a WDB_EXC_INFO structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbExcInfo
    (
    WDB_EXC_INFO *      pExcInfo        /* WDB_EXC_INFO structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_EXC_INFO\n");

    fprintf (wdbLogFile,"\t\tnumInts\t\t%d\n",(int) pExcInfo->numInts);

    fprintf (wdbLogFile,"\t\t");