bkendlog.c

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

        }

    /*
     * log the request number if we log a transmission and if the each
     * request has a number. 
     */

    if ((xmit) && (sequenceNumber != NONE))
        fprintf (wdbLogFile,"\n%d",sequenceNumber);

    /*
     * figure out the request send/receive to/from the target agent.
     * Then fill logRequestName will the WDB request name, logFuncXmit and
     * logFuncRcv with a pointer to the right log function to call.
     */

    switch (procNum)
        {
        case WDB_TARGET_PING:
            logRequestName = "WDB_TARGET_PING";
            logFuncXmit = NULL;
            logFuncRcv = NULL;
            break;

        case WDB_TARGET_CONNECT :
            logRequestName = "WDB_TARGET_CONNECT";
            logFuncXmit = NULL;
            logFuncRcv = bkendLogWdbTgtInfo;
            break;

        case WDB_TARGET_DISCONNECT :
            logRequestName = "WDB_TARGET_DISCONNECT";
            logFuncXmit = NULL;
            logFuncRcv = NULL;
            break;

        case WDB_TARGET_MODE_SET :
            logRequestName = "WDB_TARGET_MODE_SET";
            logFuncXmit = bkendLogWdbAgentMode;
            logFuncRcv = NULL;
            break;

        case WDB_TARGET_MODE_GET :
            logRequestName = "WDB_TARGET_MODE_GET";
            logFuncXmit = NULL;
            logFuncRcv = bkendLogWdbAgentMode;
            break;

        case WDB_MEM_READ :
            logRequestName = "WDB_MEM_READ";
            logFuncXmit = bkendLogWdbMemRegion;
            logFuncRcv = bkendLogWdbMemXfer;
            break;
                 
        case WDB_MEM_WRITE :
            logRequestName = "WDB_MEM_WRITE";
            logFuncXmit = bkendLogWdbMemXfer;
            logFuncRcv = NULL;
            break;
                 
        case WDB_MEM_FILL :
            logRequestName = "WDB_MEM_FILL";
            logFuncXmit = bkendLogWdbMemRegion;
            logFuncRcv = NULL;
            break;
                 
        case WDB_MEM_MOVE :
            logRequestName = "WDB_MEM_MOVE";
            logFuncXmit = bkendLogWdbMemRegion;
            logFuncRcv = NULL;
            break;
                 
        case WDB_MEM_CHECKSUM :
            logRequestName = "WDB_MEM_CHECKSUM";
            logFuncXmit = bkendLogWdbMemRegion;
            logFuncRcv = bkendLogWdbUINT32;
            break;

        case WDB_MEM_PROTECT :
            logRequestName = "WDB_MEM_PROTECT";
            logFuncXmit = bkendLogWdbMemRegion;
            logFuncRcv = NULL;
            break;
                 
        case WDB_MEM_CACHE_TEXT_UPDATE :
            logRequestName = "WDB_MEM_CACHE_TEXT_UPDATE";
            logFuncXmit = bkendLogWdbMemRegion;
            logFuncRcv = NULL;
            break;
                 
        case WDB_MEM_SCAN :
            logRequestName = "WDB_MEM_SCAN";
            logFuncXmit = bkendLogWdbMemScanDesc;
            logFuncRcv = bkendLogWdbTGT_ADDR_T;
            break;
                 
        case WDB_MEM_WRITE_MANY :
            logRequestName = "WDB_MEM_WRITE_MANY";
            logFuncXmit = NULL;
            logFuncRcv = NULL;
            break;
                 
        case WDB_MEM_WRITE_MANY_INT :
            logRequestName = "WDB_MEM_WRITE_MANY_INTS";
            logFuncXmit = NULL;
            logFuncRcv = NULL;
            break;
                 
        case WDB_CONTEXT_CREATE :
            logRequestName = "WDB_CONTEXT_CREATE";
            logFuncXmit = bkendLogWdbCtxCreateDesc;
            logFuncRcv = bkendLogWdbUINT32;
            break;
                 
        case WDB_CONTEXT_KILL :
            logRequestName = "WDB_CONTEXT_KILL";
            logFuncXmit = bkendLogWdbContext;
            logFuncRcv = NULL;
            break;
                  
        case WDB_CONTEXT_SUSPEND :
            logRequestName = "WDB_CONTEXT_SUSPEND";
            logFuncXmit = bkendLogWdbContext;
            logFuncRcv = NULL;
            break;
                 
        case WDB_CONTEXT_RESUME :
            logRequestName = "WDB_CONTEXT_RESUME";
            logFuncXmit = bkendLogWdbContext;
            logFuncRcv = NULL;
            break;
                 
        case WDB_REGS_GET :
            logRequestName = "WDB_REGS_GET";
            logFuncXmit = bkendLogWdbRegReadDesc;
            logFuncRcv = bkendLogWdbMemXfer;
            break;
                 
        case WDB_REGS_SET :
            logRequestName = "WDB_REGS_SET";
            logFuncXmit = bkendLogWdbRegWriteDesc;
            logFuncRcv = NULL;
            break;
                 
        case WDB_VIO_WRITE :
            logRequestName = "WDB_VIO_WRITE";
            logFuncXmit = bkendLogWdbMemXfer;
            logFuncRcv = bkendLogWdbUINT32;
            break;
                 
        case WDB_EVENTPOINT_ADD :
            logRequestName = "WDB_EVENTPOINT_ADD";
            logFuncXmit = bkendLogWdbEvtptAddDesc;
            logFuncRcv = bkendLogWdbUINT32;
            break;
                 
        case WDB_EVENTPOINT_DELETE :
            logRequestName = "WDB_EVENTPOINT_DELETE";
            logFuncXmit = bkendLogWdbEvtptDelDesc;
            logFuncRcv = NULL;
            break;
                 
        case WDB_EVENT_GET :
            logRequestName = "WDB_EVENT_GET";
            logFuncXmit = NULL;
            logFuncRcv = bkendLogWdbEvtData;
            break;
                 
        case WDB_CONTEXT_CONT :
            logRequestName = "WDB_CONTEXT_CONT";
            logFuncXmit = bkendLogWdbContext;
            logFuncRcv = NULL;
            break;
                 
        case WDB_CONTEXT_STEP :
            logRequestName = "WDB_CONTEXT_STEP";
            logFuncXmit = bkendLogWdbCtxStepDesc;
            logFuncRcv = NULL;
            break;
                 
        case WDB_FUNC_CALL :
            logRequestName = "WDB_FUNC_CALL";
            logFuncXmit = bkendLogWdbCtxCreateDesc;
            logFuncRcv = bkendLogWdbUINT32;
            break;
                 
        case WDB_EVALUATE_GOPHER :
            logRequestName = "WDB_EVALUATE_GOPHER";
            logFuncXmit = bkendLogWdbString;
            logFuncRcv = bkendLogWdbMemXfer;
            break;
                 
        case WDB_DIRECT_CALL :
            logRequestName = "WDB_DIRECT_CALL";
            logFuncXmit = bkendLogWdbCtxCreateDesc;
            logFuncRcv = bkendLogWdbUINT32;
            break;
                 
        case WDB_CONTEXT_STATUS_GET :
            logRequestName = "WDB_CONTEXT_STATUS_GET";
            logFuncXmit = bkendLogWdbContext;
            logFuncRcv = bkendLogWdbCtxStatus;
            break;
                 
        default :
            logRequestName = "UNKNOWN_REQUEST";
            logFuncXmit = NULL;
            logFuncRcv = NULL;
            break;
        }

    if (xmit) 
        {
        /*
         * we are in transmission case, so log the WDB request name and 
         * call the function pointed to by logFuncXmit if not NULL.
         */
      
        fprintf (wdbLogFile,"\t%-40s", logRequestName);

        /* log the current time and date */

        time (&currentDate);                    /* get current time & date */

        fprintf (wdbLogFile,"%s", ctime(&currentDate));

        if (logFuncXmit != NULL)
            {
            fprintf (wdbLogFile,"\tIn\t");
            logFuncXmit (args);
            }
        }
    else 
        {
        /*
         * we are in a receiving case: log the number of time the request
         * was re-sent. If the nunber is NONE, the value is not logged.
         */

        if (timeoutNb != NONE)
            fprintf (wdbLogFile,"%d", timeoutNb);

        if ((status & ~WDB_TO_BE_CONTINUED) == OK)
            fprintf (wdbLogFile,"\tOut\tstatus:\t\tOk\n");
        else
	    {
            fprintf (wdbLogFile,"\tOut\tError:\t\t");
	    bkendLogWdbEnumToString ("ERROR_TYPE", status);
	    fprintf (wdbLogFile,"\n");
	    }

        /*
         * Call the function pointed to by logFuncRcv, if not NULL, in order
         * to log the receive structure.
         */

        if ((logFuncRcv != NULL) && ((status & ~WDB_TO_BE_CONTINUED) == OK))
            {
            fprintf (wdbLogFile,"\t\t");
            logFuncRcv (args);
            }
        }

    /* 
     * Flush the file write buffer to have all information physically in the
     * file in case the target server hang later. 
     */

    fflush (wdbLogFile);

    /* Give the backEndLog Mutex back */
 
    semGive (backEndLogMutex);
    }

/*******************************************************************************
*
* bkendLogClose - close the back end log file 
*
* This function closes the back end log file. It's called by the target server
* back end when the function pointed to by tgtDisconnectRtn is called. 
*
* RETURNS: N/A
*
* NOMANUAL
*/

void bkendLogClose ()
    {

    /* Wait for the backEndLog Mutex */
 
    if (semTake (backEndLogMutex, WAIT_FOREVER) == ERROR)
        return;

    /* if a log file is open then closed it */

    if (wdbLogFile != NULL)
        fclose (wdbLogFile);

    /* signal the back end log capability is now turned off */

    bkendLogEnable = FALSE;

    /* Delete the backEndLog Mutex */
 
    semTerminate (backEndLogMutex);
    backEndLogMutex = NULL;

    return ;
    }

/*******************************************************************************
*
* bkendLogWdbMemRegion - log a WDB_MEM_REGION structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbMemRegion
    (
    WDB_MEM_REGION *    pWdbMemRegion   /* WDB_MEM_REGION structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_MEM_REGION\n");

    fprintf (wdbLogFile,"\t\tbaseAddr\t0x%x\n", (int) pWdbMemRegion->baseAddr);
    fprintf (wdbLogFile,"\t\tnumBytes\t%d\n",(int) pWdbMemRegion->numBytes);
    fprintf (wdbLogFile,"\t\tparam\t\t%d\n", pWdbMemRegion->param);
    }

/*******************************************************************************
*
* bkendLogWdbMemXfer - log a WDB_MEM_XFER structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbMemXfer
    (
    WDB_MEM_XFER *      pWdbMemXfer     /* WDB_MEM_XFER structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_MEM_XFER\n");

    fprintf (wdbLogFile,"\t\tnumBytes\t%d\n",(int) pWdbMemXfer->numBytes);
    fprintf (wdbLogFile,"\t\tdestination\t%#x\n", 
				(int) pWdbMemXfer->destination);
    fprintf (wdbLogFile,"\t\tsource\t\t%#x\n", (u_int ) pWdbMemXfer->source);
    }

/*******************************************************************************
*
* bkendLogWdbMemScanDesc - log a WDB_MEM_SCAN_DESC structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbMemScanDesc
    (
    WDB_MEM_SCAN_DESC * pWdbMemScan     /* WDB_MEM_SCAN_DESC structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_MEM_SCAN_DESC\n");

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

    bkendLogWdbMemRegion (&pWdbMemScan->memRegion);

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

    bkendLogWdbMemXfer   (&pWdbMemScan->memXfer);
    }

/*******************************************************************************
*
* bkendLogWdbContext - log a WDB_CTX structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbContext
    (
    WDB_CTX *   pWdbContext             /* WDB_CTX structure to log */
    )
    {
    fprintf (wdbLogFile,"WDB_CTX\n");

    fprintf (wdbLogFile,"\t\tcontextType\t");
    bkendLogWdbEnumToString ("CONTEXT_TYPE", pWdbContext->contextType);
    fprintf (wdbLogFile,"\n");
    fprintf (wdbLogFile,"\t\tcontextId\t0x%x\n", pWdbContext->contextId);
    }

/*******************************************************************************
*
* bkendLogWdbCtxStepDesc - log a WDB_CTX_STEP_DESC structure
*
* RETURNS: void.
*/

LOCAL void bkendLogWdbCtxStepDesc
    (
    WDB_CTX_STEP_DESC * pWdbCtxStep     /* WDB_CTX_STEP_DESC structure to log */