wvlib.c

VXWORKS源代码

*
* wvUploadTaskConfig - set priority and stacksize of 'tWVUpload' task (WindView)
*
* This routine sets the stack size and priority of future instances of 
* the event-data upload task, created by calling wvUploadStart().  The default
* stack size for this task is 5000 bytes, and the default priority is 150.
* 
* RETURNS: N/A
*/

void wvUploadTaskConfig
    (
    int stackSize,		/* the new stack size for tWVUpload */
    int priority		/* the new priority for tWVUpload */
    )
    {
    wvUploadTaskStackSize = stackSize;
    wvUploadTaskPriority  = priority;
    }

/*******************************************************************************
*
* wvLogHeaderCreate - create the event-log header (WindView)
*
* This routine creates the header of EVENT_CONFIG, EVENT_BUFFER, and EVENT_BEGIN
* events that is required at the beginning of every event log.  These events are
* stored in a packed array allocated from the specified memory partition.
* In addition to this separate header, this routine also logs all tasks
* active in the system to the event buffer for uploading along with the
* other events.
*
* This routine should be called after wvEvtLogInit() is called.  If uploading
* events continuously to the host, this routine should be called after the 
* upload task is started.  This ensures that the upload task is included in 
* the snapshot of active tasks.  If upload will occur after event logging has 
* stopped (deferred upload), this routine can be called any time before event 
* logging is turned on.
*
* RETURNS: A valid WV_LOG_HEADER_ID, or NULL if memory can not be allocated.
*/

WV_LOG_HEADER_ID wvLogHeaderCreate 
    (
    PART_ID   memPart		/* partition where header should be stored */
    )
    {
    WV_LOG_HEADER *pHead;	/* local copy of the log header struct */
    int		  *pIntCur;	/* integer pointer into buf */
    short	  *pShortCur;	/* short pointer into buf */
    char	  *pByteCur;	/* char pointer into buf */


    short cfgEventId;           /* EVENT_CONIG */
    int   cfgProtocolRev;
    int   cfgTimestampFreq;
    int   cfgTimestampPeriod;
    int   cfgAutoRollover;
    int   cfgClkRate;
    int   cfgCollectionMode;
    int   cfgProcessorNum;

    short bufEventId;           /* EVENT_BUFFER */
    int   bufTaskIdCurrent;

    short begEventId;           /* EVENT_BEGIN */
    int   begCpu;
    int   begBspSize;           /* char *begBspName copied directly to buf */
    int   begTaskIdCurrent;
    int   begCollectionMode;
    int   begRevision;

    char  commentString[] = "Windview Version 2.2 Logfile.  Copyright \
 1999-2001 Wind River Systems.";

    int   commentLen;
    int   bspLen;
    
    /* 
     * Get the actual log header structure first, and then figure out how
     * big to make it, considering the variable-length bspName field.
     */

    pHead = (WV_LOG_HEADER *) memPartAlloc (memPart, sizeof (WV_LOG_HEADER));

    if (pHead == NULL)
	return (NULL);

    commentLen = strlen (commentString);

    if (commentLen & 1)
        commentLen++;
    
    bspLen = strlen (sysModel ());

    if (bspLen & 1)
        bspLen++;
    
    pHead->len = (EVENT_BEGIN_SIZE + EVENT_CONFIG_SIZE + EVENT_BUFFER_SIZE +
		  commentLen + EVENT_COMMENT_SIZE +
                  bspLen);

    if (pHead->len & 1)
	++pHead->len;

    pHead->header = memPartAlloc (memPart, pHead->len);

    if (pHead->header == NULL)
	{
	memPartFree (memPart, (char *) pHead);
	return (NULL);
	}

    pHead->memPart = memPart;


    /*
     * Get memory for an EVENT_CONFIG buffer from the event buffer, using
     * the writeReserve interface.  Then fill in that memory.
     */

    cfgEventId         = EVENT_CONFIG;
    cfgProtocolRev     = WV_REV_ID_CURRENT | WV_EVT_PROTO_REV_CURRENT;
    cfgTimestampFreq   = (* _func_tmrFreq) ();
    cfgTimestampPeriod = (* _func_tmrPeriod) ();
    cfgAutoRollover    = ((* _func_tmrConnect) ((FUNCPTR) _func_evtLogT0,
                                                EVENT_TIMER_ROLLOVER)) + 1;
    cfgClkRate         = sysClkRateGet ();
    cfgCollectionMode  = (int)(wvEvtClass & WV_CLASS_3);
    cfgProcessorNum    = sysProcNumGet ();

    pShortCur = (short *) pHead->header;

    EVT_STORE_UINT16 (pShortCur, cfgEventId);
    pIntCur   = (int *) pShortCur;
    EVT_STORE_UINT32 (pIntCur, cfgProtocolRev);
    EVT_STORE_UINT32 (pIntCur, cfgTimestampFreq);
    EVT_STORE_UINT32 (pIntCur, cfgTimestampPeriod);
    EVT_STORE_UINT32 (pIntCur, cfgAutoRollover);
    EVT_STORE_UINT32 (pIntCur, cfgClkRate);
    EVT_STORE_UINT32 (pIntCur, cfgCollectionMode);
    EVT_STORE_UINT32 (pIntCur, cfgProcessorNum);

    /*
     * Log the EVENT_LOGCOMMENT event to the buffer.
     */

    begEventId        = EVENT_LOGCOMMENT;

    pShortCur = (short *) pIntCur;

    EVT_STORE_UINT16 (pShortCur, begEventId);
    pIntCur   = (int *) pShortCur;
    EVT_STORE_UINT32 (pIntCur, commentLen);

    pByteCur = (char *) pIntCur;
    strncpy (pByteCur, commentString, commentLen);
    pByteCur += commentLen;

    pIntCur   = (int *) pByteCur;

    /*
     * Do the same for an EVENT_BUFFER.  Reserve memory for the event from
     * the event buffer, and then fill in that memory.
     */

    bufEventId       = EVENT_BUFFER;
    bufTaskIdCurrent = (kernelIsIdle) ? (int) ERROR : (int) taskIdCurrent;

    pShortCur = (short *) pIntCur;

    EVT_STORE_UINT16 (pShortCur, bufEventId);
    pIntCur   = (int *) pShortCur;
    EVT_STORE_UINT32 (pIntCur, bufTaskIdCurrent);

    /*
     * Log the EVENT_BEGIN event to the buffer.  The cpu-type member is
     * tricky because it has to be of even length to transfer to the host.
     * Also the memory reserved has to vary by its length.
     */

    begEventId        = EVENT_BEGIN;
    begCpu            = sysCpu;

    begBspSize        = bspLen;
    begTaskIdCurrent  = (int) taskIdCurrent;
    begCollectionMode  = (int)(wvEvtClass & WV_CLASS_3);
    begRevision       = WV_EVT_PROTO_REV_CURRENT;

    pShortCur = (short *) pIntCur;

    EVT_STORE_UINT16 (pShortCur, begEventId);
    pIntCur   = (int *) pShortCur;
    EVT_STORE_UINT32 (pIntCur, begCpu);
    EVT_STORE_UINT32 (pIntCur, begBspSize);

    pByteCur = (char *) pIntCur;
    strncpy (pByteCur, sysModel(), begBspSize);
    pByteCur += begBspSize;

    pIntCur   = (int *) pByteCur;
    EVT_STORE_UINT32 (pIntCur, begTaskIdCurrent);
    EVT_STORE_UINT32 (pIntCur, begCollectionMode);
    EVT_STORE_UINT32 (pIntCur, begRevision);


    /* Log a snapshot of active tasks to the event buffer. */

    evtLogTasks ();

    return (pHead);
    }

/*******************************************************************************
*
* wvLogHeaderUpload - transfer the log header to the host (WindView)
*
* This functions transfers the log header events (EVENT_BEGIN, EVENT_CONFIG,
* EVENT_BUFFER) to the host.  These events were saved to a local buffer
* with the call to wvLogHeaderCreate().  This routine should be called before
* any events or tasknames are uploaded to the host.  The events in the 
* header buffer must be the first things the parser sees.
*
* If continuously uploading events, it is best to start the uploader, and 
* then call this routine.  If deferring upload until after event logging
* is stopped, this should be called before the uploader is started.
*
* RETURNS: OK, or ERROR if there is trouble with the upload path.
*/

STATUS wvLogHeaderUpload
    (
    WV_LOG_HEADER_ID pHeader,		/* pointer to the header */
    UPLOAD_ID pathId			/* path by which to upload to host */
    )
    {
    int 	   res;			/* partly notice write errors */

    if (pHeader == NULL || pathId == NULL)
	return (ERROR);

    res = pathId->writeRtn (pathId, pHeader->header, pHeader->len);

    if (res < 0)
	return (ERROR);

    if (pmPartId != NULL)
        {

    	/* Free the header. */

    	memPartFree (pHeader->memPart, (char *) pHeader->header);
    	memPartFree (pHeader->memPart, (char *) pHeader);
	}

    return (OK);
    }

/*******************************************************************************
*
* wvEvtBufferGet - return the ID of the WindView event buffer (WindView)
*
* RETURNS: The event buffer ID if one exists, otherwise NULL.
*/

BUFFER_ID wvEvtBufferGet (void)
    {
    return ((wvEvtBufferId == 0) ? (BUFFER_ID) NULL : wvEvtBufferId);
    }

/*******************************************************************************
*
* wvTaskNamesPreserve - preserve an extra copy of task name events (WindView)
*
* This routine initializes the data structures and instrumentation necessary
* to allow WindView to store an extra copy of each EVENT_TASKNAME event,
* which is necessary for post-mortem analysis.  This routine should be called
* after wvEvtLogInit() has been called, and before event logging is started.
*
* If this routine is called before event logging is started, all
* EVENT_TASKNAME events that are produced by VxWorks are logged into the
* standard event buffer, and a copy of each is logged automatically to the
* task name buffer created by this routine.  All tasks running when this 
* routine is called are also added to the buffer.  The events in this buffer
* can be uploaded after the other events have been uploaded, to provide the
* task names for any events in the log which no longer have a corresponding
* task name event due to wrapping of data in the buffers.  Because there
* may be two copies of some of the task name events after the buffer data
* wraps around, the resultant log may have two task name events for the same
* task.  This is not a problem for the parser.
*
* Occasionally the task ID of a task is reused, and in this case, only
* the last instance of the task name event with a particular task ID is
* maintained.
*
* The buffer size must be a power of two.
*
* This routine sets the event class WV_CLASS_TASKNAMES_PRESERVE, which can
* be turned off by calling wvEvtClassClear() or wvEvtClassSet().
*
* INTERNAL
* This routine returns the buffer's ID, which is required later to
* destroy and upload the buffer.  The ID is not required to add an event
* to the buffer.  That is because additions to the buffer will be done
* from an event point, and the event point will not have access to the
* buffer's ID.  This is exactly how the event buffer is accessed in 
* evtLogLib.
*
* The buffer used to store the reserved taskname events is a hash table that 
* is implemented in wvLib.  All functions associated with this hash table are
* prefixed with tnHashTbl.  The implementation of the reserved taskname buffer
* has been hidden (albeit barely) from this function, so that any implemen-
* tation of a buffer can be used.  The type of the buffer is identified as 
* a TASKBUF_ID.  The specific implementation of the hash-table buffer is 
* a TN_HASH_TBL.
* 
* A hash table has been used because, given very specific circumstances, the
* task IDs of tasks with different names may be reused.  A hash table allows
* easy and fast replacement of the names, so that there is only one name per
* tid in the table at any time.  As new names, corresponding to a given tid,
* are added, the event is replaced with the newest event.
*
* The hash table was used to avoid multiple taskname events with the same tid,
* however there may be a copy of the same event still in the buffer, providing
* it has not been overwritten.  In this case there will be two of the same
* events anyway, so the hash table is overkill.  Oh well.
*
* RETURNS: A valid TASKBUF_ID to be used for later uploading, or NULL if 
* not enough memory exists to create the task buffer.
*/

TASKBUF_ID wvTaskNamesPreserve
    (
    PART_ID memPart,		/* memory where preserved names are stored */
    int	    size 		/* must be a power of 2 */
    )
    {
    int 	   nTasks;			/* number of active tasks */
    int		   idList [MAX_WV_TASKS]; 	/* list of active task IDs */
    int		   ix;				/* counting index */
    TN_HASH_TBL   *pTbl;			/* the taskname buffer */

    /* Create the buffer where names will be stored. */

    if ((pTbl = tnHashTblCreate (memPart, size)) == NULL)
	return (NULL);

    /* 
     * Stash a copy of the the buffer id for table adds, directly from
     * event points later.   This has to be done before we add any names.
     */

    tnHashTbl   = pTbl;

    /* Store a copy of each taskname already running in the system. */

    nTasks = taskIdListGet (idList, NELEMENTS (idList));

    for (ix = 0; ix < nTasks; ++ix)
	{
	if (taskIdVerify (idList [ix]) == OK)
	    {
	    wvTaskNamesBufAdd (EVENT_TASKNAME,
			       ((WIND_TCB *)idList[ix])->status,
			       ((WIND_TCB *)idList[ix])->priority,
			       ((WIND_TCB *)idList[ix])->lockCnt,
			       idList [ix], taskName (idList [ix]));
            }
        }

    /* 
     * Let the event point know that it should reserve a copy of each 
     * future event. It will be turned off when event loggin is turned 
     * off or reset.
     */

    WV_EVTCLASS_SET (WV_CLASS_TASKNAMES_PRESERVE);