开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
evtLogLib.c
资源名称：vxWorks_src.rar　[点击查看]
上传用户：baixin
上传日期：2008-03-13
资源大小：4795k
文件大小：26k
源码类别：

嵌入式/单片机编程

开发平台：

MultiPlatform

evtLogLib.c：源码内容
  1. /* evtLogLib.c - event logging library */
  3. /* Copyright 1994-1998 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03m,14aug98,cth  removed MEM_ROUND_UP from evtLogPoint
  10. 03m,10aug98,pr   added i960 function pointers to evtLogFuncBind
  11. 03l,30jul98,cjtc removed logMsg EVTLOG_RESERVE_BUFF_SPACE macros which resulted
  12.  in stack corruption of the calling task (SPR 21993)
  13. 03k,13may98,pr   modified logMsg content
  14. 03j,12may98,pr   added logMsg and stop windview if buffer is full
  15. 03i,17apr98,cth  removed function evtHeaderLog
  16. 03h,15apr98,cth  added binding of _func_evtLogReserveTaskName
  17. 03g,10apr98,cjtc architecture port for i960 processors.
  18.  fixed bug in evtLogT0_noInt in which timestamp was written to
  19.  the event buffer before it was read.
  20.  Removed unused local variable "level" from evtLogT0_noInt
  21. 03f,09apr98,pr   added evtLogT0_noInt declaration
  22. 03e,08apr98,pr   modified evtLogO to be of general use. Added evtLogT0_noInt
  23. 03d,06apr98,nps  68k family nows shares portable code.
  24. 03c,18mar98,nps  fixed check for 'thin' mode when creating header.
  25. 03b,17feb98,dvs  added events for memory instrumentation in evtLogO and 
  26.     pr  fixed evtLogO buffer size.
  27. 03a,03feb98,cth  changed evtBufferId from static to global
  28. 02z,27jan98,cth  added evtObjLogFuncBind, evtLogFuncBind, evtBufferBind and
  29.  evtHeaderLog, updated copyright
  30. 02y,25jan98,pr   changed size in evtLogT1_noTS
  31. 02x,22jan98,pr   fixed evtsched
  32. 02w,18dec97,cth  changed include buffer.h to wvBufferP.h, changed tmpBufId to
  33.  evtBufferId
  34. 02v,16nov97,cth  removed evtBuf and rBuff references 
  35.  changed buffer writes to use generic WV2.0 buffers
  36. 02u,22oct97,pr   fixed EVTLOG_RESERVE_BUFF_SPACE_L for evtLogT1_noTS
  37. 02t,21oct97,nps  use modified rBuff API
  38. 02s,18aug97,nps  fixed bug in evtLogM1
  39. 02r,20jul97,nps  added ring buffer support
  40. 02q,24jun97,pr   commented the evtLogTIsOn for evtLogPoint
  41. 02p,08jul96,pr   added evtLogT1_noTS for PPC
  42. 02o,06dec94,rdc  fixed bogus intlocks that should have been unlocks.
  43. 02n,08nov94,rdc  added 960 kernel instrumentation routines.
  44. 02m,02nov94,rdc  added argument to evtLogString to support lockCount param
  45.  in EVENT_TASKNAME.
  46. 02l,02nov94,rdc  unlocked interrupts before returning because of errors.
  47. 02k,27may94,smb  now use alignment macros to store data in buffer.
  48. 02j,23may94,pme  removed taskIdLogin for EVENT_WIND_EXIT_NODISPATCH
  49.  made evtsched equivalent to the 68k assembly version
  50. 01i,05may94,smb  sparc porting
  51. 01h,16mar94,smb  removed EVENT_WIND_EXIT_IDLENOT
  52.  level 1 optimisations.
  53. 01g,22feb94,smb  changed typedef EVENT_TYPE to event_t (SPR #3064)
  54. 01f,24jan94,smb  fixed return values for eventPoint()
  55. 01e,19jan94,smb  event buffer fix SPR #2904
  56. 01d,14jan94,c_s  evtLogOInt now handles EVENT_SIGWRAPPER correctly (SPR #2883).
  57. 01c,04jan94,c_s  evtLogPoint now validates the user event ID correctly. 
  58.    SPR #2724.
  59. 01b,30dec93,c_s  evtLogPoint now uses memcpy (), rather than strncpy (), to 
  60.    transfer the user's buffer of data for user-defined events
  61.    to the logging area.  SPR #2799.
  62. 01a,10dec93,smb  created
  63. */
  65. /*
  66. DESCRIPTION
  67. This library provides routines which log events to the buffer for different
  68. types of events generated by the instrumented code.
  70. INCLUDE FILES: 
  72. SEE ALSO: 
  73. NOMANUAL
  74. */
  76. #include "vxWorks.h"
  77. #include "intLib.h"
  78. #include "logLib.h"
  79. #include "wvLib.h"
  80. #include "string.h"
  81. #include "taskLib.h"
  82. #include "sysLib.h"
  84. #include "private/taskLibP.h"
  85. #include "private/eventP.h"
  86. #include "private/kernelLibP.h"
  87. #include "private/workQLibP.h"
  88. #include "private/wvBufferP.h"
  89. #include "private/evtLogLibP.h"
  90. #include "private/kernelLibP.h"
  93. /* optimized version no longer used for 680X0 */
  95. #define evtLogLib_PORTABLE
  97. /* defines */
  99. #define MAX_WV_TASKS    500        /* should be the same MAX_DSP_TASKS */
  101. #define EVTLOG_RESERVE_BUFF_SPACE(EVENT_SIZE)                     
  102. eventBase = (event_t *) evtBufferId->writeRtn (evtBufferId,NULL,EVENT_SIZE);  
  103.                                                                   
  104. if (!eventBase)                                                   
  105.     {                                                             
  106.     wvEvtLogStop();   
  107.     intUnlock (level);                                            
  108.     return;                                                       
  109.     }
  111. #define EVTLOG_RESERVE_BUFF_SPACE_STAT(EVENT_SIZE)                
  112. eventBase = (event_t *) evtBufferId->writeRtn (evtBufferId,NULL,EVENT_SIZE);  
  113.                                                                   
  114. if (!eventBase)                                                   
  115.     {                                                             
  116.     wvEvtLogStop();   
  117.     intUnlock (level);                                            
  118.     return (ERROR);                                               
  119.     }
  121. #define EVTLOG_RESERVE_BUFF_SPACE_L(EVENT_SIZE)                   
  122. eventBase = (event_t *) evtBufferId->writeRtn (evtBufferId,NULL,EVENT_SIZE);  
  123.                                                                   
  124. if (!eventBase)                                                   
  125.     {                                                             
  126.     wvEvtLogStop();   
  127.     return;                                                       
  128.     }
  132. /* globals */
  134. IMPORT Q_HEAD readyQHead; /* multi-way ready queue head */
  136. /* local */
  138. BUFFER_ID evtBufferId;             /* event buffer identifier */
  141. /* forward declarations */
  143. void evtLogTasks (void);
  144. void evtLogOInt  (event_t  action, int nParam, int param1, int param2, 
  145. int param3, int param4, int param5);
  146. void evtLogO     (event_t action, int nParam, int param1, int param2, 
  147. int param3, int param4, int param5);
  148. void evtLogString (event_t action, int arg1, int arg2, int arg3,
  149. int addrId, const char *string);
  150. int evtLogPoint  (event_t action, void * addr, size_t nbytes, 
  151. char * buffer);
  152. void evtsched ( event_t action, int arg1, int arg2);
  154. void evtLogM0  (event_t action);
  155. void evtLogM1  (event_t action, int param1);
  156. void evtLogM2  (event_t action, int param1, int param2);
  157. void evtLogM3  (event_t action, int param1, int param2, int param3);
  158. void evtLogT0  (event_t action);
  159. void evtLogT0_noInt  (event_t action);
  160. void evtLogT1  (event_t action, int param);
  162. #if CPU_FAMILY==PPC
  164. void evtLogT1_noTS  (event_t action, int param);
  166. #endif /* CPU_FAMILY==PPC */
  168. #if CPU_FAMILY==I960
  170. void windInst1 (void);
  171. void windInstDispatch (void);
  172. void windInstIdle (void);
  173. void windInstIntEnt (void);
  174. void windInstIntExit (void);
  176. #endif /* CPU_FAMILY==I960 */
  178. /*******************************************************************************
  179. *
  180. * evtObjLogFuncBind - bind object-level logging functions
  181. *
  182. * This routine binds the function pointers used to log system-object events
  183. * to the appropriate functions in this library.
  184. *
  185. * RETURNS: N/A
  186. * NOMANUAL
  187. */
  189. void evtObjLogFuncBind (void)
  190.     {
  191.     _func_evtLogO        = (VOIDFUNCPTR) evtLogO;
  192.     _func_evtLogOIntLock = (VOIDFUNCPTR) evtLogOInt;
  193.     }
  195. /*******************************************************************************
  196. *
  197. * evtLogFuncBind - bind general event-logging functions
  198. *
  199. * This function binds instrumentation function pointers to logging functions
  200. * in this file.  Event logging routines associated with class-1 (object-
  201. * class) logging must be bound earlier, with a call to evtObjLogFuncBind.
  202. *
  203. * RETURNS: N/A
  204. * NOMANUAL
  205. */
  207. void evtLogFuncBind (void)
  208.     {
  210.     /* Task-transition logging. */
  212.     _func_evtLogM0 = (VOIDFUNCPTR) evtLogM0;    
  213.     _func_evtLogM1 = (VOIDFUNCPTR) evtLogM1;
  214.     _func_evtLogM2 = (VOIDFUNCPTR) evtLogM2;
  215.     _func_evtLogM3 = (VOIDFUNCPTR) evtLogM3;
  217.     /* Context-switch logging. */
  219.     _func_evtLogT0 = (VOIDFUNCPTR) evtLogT0;    
  220.     _func_evtLogT1 = (VOIDFUNCPTR) evtLogT1;
  221.     _func_evtLogT0_noInt = (VOIDFUNCPTR) evtLogT0_noInt;
  222. #if CPU_FAMILY==PPC
  223.     _func_evtLogT1_noTS = (VOIDFUNCPTR) evtLogT1_noTS;
  224. #endif /* CPU_FAMILY==PPC */
  225.     _func_evtLogTSched = (VOIDFUNCPTR) evtsched;  /* iff portable kernel */
  227.     /* Special logging functions. */
  229.     _func_evtLogPoint = (FUNCPTR) evtLogPoint;
  230.     _func_evtLogString = (VOIDFUNCPTR) evtLogString;
  231.     _func_evtLogReserveTaskName = (FUNCPTR) wvTaskNamesBufAdd;
  233.     /* i960 specific functione pointers used in windALib.s */
  235. #if CPU_FAMILY==I960
  237.     _func_windInst1 = (VOIDFUNCPTR) windInst1;
  238.     _func_windInstDispatch = (VOIDFUNCPTR) windInstDispatch;
  239.     _func_windInstIdle = (VOIDFUNCPTR) windInstIdle;
  240.     _func_windInstIntEnt = (VOIDFUNCPTR) windInstIntEnt;
  241.     _func_windInstIntExit = (VOIDFUNCPTR) windInstIntExit;
  243. #endif /* CPU_FAMILY==I960 */
  245.     }
  247. /*******************************************************************************
  248. *
  249. * evtBufferBind - bind logging routines to a specific event buffer
  250. *
  251. * This routine associates a specific event buffer with the event-logging
  252. * routines.
  253. *
  254. * RETURNS: N/A
  255. * NOMANUAL
  256. */
  258. void evtBufferBind
  259.     (
  260.     BUFFER_ID bufId /* bind logging functions to this buffer */
  261.     )
  262.     {
  263.     evtBufferId = bufId;
  264.     }
  266. #ifdef evtLogLib_PORTABLE
  268. /*******************************************************************************
  269. *
  270. * evtLogT0 - log event id
  271. *
  272. * This event logging routine stores
  273. *       event id        (short )
  274. *       time (int )
  275. * This routine is called by level 3 (context switch events) 
  276. * taskLock, taskUnlock and tickAnnounce.
  277. *
  278. * SEE ALSO:
  279. * NOMANUAL
  280. */
  282. void evtLogT0
  283.     (
  284.     event_t action           /* event id */
  285.     )
  286.     {
  287.     int              level;                  /* interrupt level */
  288.     event_t *        eventBase;
  289.     int *            intBase;
  290.     int      timestamp;
  292.     level = intLock ();                 /* LOCK INTERRUPTS */
  294.     EVTLOG_RESERVE_BUFF_SPACE(EVTLOG_T0_SIZE);
  296.     EVT_STORE_UINT16 (eventBase, action);
  297.     intBase = (int *) eventBase;
  298.     timestamp = (* _func_tmrStamp) ();
  299.     EVT_STORE_UINT32 (intBase, timestamp);
  301.     intUnlock (level);                  /* UNLOCK INTERRUPTS */
  302.     }
  304. /*******************************************************************************
  305. *
  306. * evtLogT0_noInt - log event id without locking interrupts 
  307. *
  308. * This event logging routine stores
  309. *       event id        (short )
  310. *       time            (int )
  311. * This routine is called by level 3 (context switch events) when interrupt
  312. * are already locked (in particular by arch dependent code).
  313. *
  314. * SEE ALSO:
  315. * NOMANUAL
  316. */
  319. void evtLogT0_noInt
  320.     (
  321.     event_t action           /* event id */
  322.     )
  323.     {
  324.     event_t *        eventBase;
  325.     int *            intBase;
  326.     int      timestamp;
  328.     EVTLOG_RESERVE_BUFF_SPACE_L(EVTLOG_T0_SIZE);
  330.     EVT_STORE_UINT16 (eventBase, action);
  331.     intBase = (int *) eventBase;
  332.     timestamp = (* _func_tmrStamp) ();
  333.     EVT_STORE_UINT32 (intBase, timestamp);
  335.     }
  337. /*******************************************************************************
  338. *
  339. * evtLogT1 - log event id
  340. *
  341. * This event logging routine stores
  342. *       event id        (short )
  343. *       time            (int )
  344. *       param           (int )
  345. *
  346. * This routine is called by level 3 (context switch events)
  347. * taskLock, taskUnlock and tickAnnounce.
  348. *
  349. * SEE ALSO:
  350. * NOMANUAL
  351. */
  353. void evtLogT1
  354.     (
  355.     event_t action,          /* event id */
  356.     int     param
  357.     )
  358.     {
  359.     int             level;                  /* interrupt level */
  360.     event_t *        eventBase = NULL;
  361.     int *            intBase = NULL;
  362.     int      timestamp;
  364.     level = intLock ();                 /* LOCK INTERRUPTS */
  366.     EVTLOG_RESERVE_BUFF_SPACE(EVTLOG_T1_SIZE);
  368.     EVT_STORE_UINT16 (eventBase, action);
  369.     intBase = (int *) eventBase;
  370.     timestamp = (* _func_tmrStamp) ();
  371.     EVT_STORE_UINT32 (intBase, timestamp);
  372.     EVT_STORE_UINT32 (intBase, param);
  374.     intUnlock (level);                  /* UNLOCK INTERRUPTS */
  375.     }
  378. /*******************************************************************************
  379. *
  380. * evtLogM0 - log event id 
  381. * 
  382. * This event logging routine stores
  383. * event id (short )
  384. *
  385. * SEE ALSO:
  386. * NOMANUAL
  387. */
  389. void evtLogM0 
  390.     (
  391.     event_t action /* event id */
  392.     )
  393.     {
  394.     int              level; /* interrupt level */
  395.     event_t *        eventBase;
  397.     level = intLock ();                 /* LOCK INTERRUPTS */
  399.     EVTLOG_RESERVE_BUFF_SPACE(EVTLOG_M0_SIZE);
  401.     EVT_STORE_UINT16 (eventBase, action);
  403.     intUnlock (level);                  /* UNLOCK INTERRUPTS */
  404.     }
  406. /*******************************************************************************
  407. *
  408. * evtLogM1 - log an event 
  409. *
  410. * This event logging routine stores
  411. *       event id        (short )
  412. *       param1          (int )
  413. *
  414. * SEE ALSO:
  415. * NOMANUAL
  416. */
  418. void evtLogM1
  419.     (
  420.     event_t action,
  421.     int     param1
  422.     )
  423.     {
  424.     int              level;
  425.     event_t *       eventBase;
  426.     int *            intBase;
  428.     level = intLock ();                 /* LOCK INTERRUPTS */
  430.     EVTLOG_RESERVE_BUFF_SPACE(EVTLOG_M1_SIZE);
  432.     EVT_STORE_UINT16 (eventBase, action);
  433.     intBase = (int *) eventBase;
  434.     EVT_STORE_UINT32 (intBase, param1);
  436.     intUnlock (level);                  /* UNLOCK INTERRUPTS */
  437.     }
  439. /*******************************************************************************
  440. *
  441. * evtLogM2 - log an event 
  442. * 
  443. * This event logging routine stores
  444. * event id (short )
  445. * param1 (int )
  446. * param2 (int )
  447. *
  448. * SEE ALSO:
  449. * NOMANUAL
  450. */
  452. void evtLogM2
  453.     (
  454.     event_t action, 
  455.     int     param1, 
  456.     int     param2
  457.     )
  458.     {
  459.     int              level;
  460.     event_t *        eventBase;
  461.     int *            intBase;
  463.     level = intLock ();                 /* LOCK INTERRUPTS */
  465.     EVTLOG_RESERVE_BUFF_SPACE(EVTLOG_M2_SIZE);
  467.     EVT_STORE_UINT16 (eventBase, action);
  468.     intBase = (int *) eventBase;
  469.     EVT_STORE_UINT32 (intBase, param1);
  470.     EVT_STORE_UINT32 (intBase, param2);
  472.     intUnlock (level);                  /* UNLOCK INTERRUPTS */
  473.     }
  475. /*******************************************************************************
  476. *
  477. * evtLogM3 - log an event 
  478. *
  479. * This event logging routine stores
  480. * event id (short )
  481. * param1 (int )
  482. * param2 (int )
  483. * param3 (int )
  484. *
  485. * SEE ALSO:
  486. * NOMANUAL
  487. */
  489. void evtLogM3
  490.     (
  491.     event_t action,
  492.     int     param1,
  493.     int     param2,
  494.     int     param3
  495.     )
  496.     {
  497.     int              level;
  498.     event_t *        eventBase;
  499.     int *            intBase;
  501.     level = intLock ();                 /* LOCK INTERRUPTS */
  503.     EVTLOG_RESERVE_BUFF_SPACE(EVTLOG_M3_SIZE);
  505.     EVT_STORE_UINT16 (eventBase, action);
  506.     intBase = (int *) eventBase;
  507.     EVT_STORE_UINT32 (intBase, param1);
  508.     EVT_STORE_UINT32 (intBase, param2);
  509.     EVT_STORE_UINT32 (intBase, param3);
  511.     intUnlock (level);                  /* UNLOCK INTERRUPTS */
  512.     }
  514. #endif /* evtLogLib_PORTABLE */
  516. /*******************************************************************************
  517. *
  518. * evtLogOInt - For level 1s, the object state events.
  519. *
  520. * This event logging routine stores
  521. * event id (short )
  522. * timestamp (int )
  523. * param[0..5] (int )  - no. of param logged depends on the event id.
  524. *
  525. * This routine is used when interrupts must be locked by this code.
  526. *
  527. * SEE ALSO:
  528. * NOMANUAL
  529. */
  531. void evtLogOInt 
  532.     (
  533.     event_t  action,     /* event action */
  534.     int      nParam,
  535.     int      param1,
  536.     int      param2,
  537.     int      param3,
  538.     int      param4,
  539.     int      param5
  540.     )
  541.     {
  542.     int level;
  544.     level = intLock();
  546.     evtLogO(action, nParam, param1, param2, param3, param4, param5);
  548.     intUnlock(level);
  549.     }
  551. /*******************************************************************************
  552. *
  553. * evtLogO - For level 1s, the object state events.
  554. *
  555. * This event logging routine stores
  556. * event id (short )
  557. * timestamp (int )
  558. * param[0..5] (int )  - no. of param logged depends on the event id.
  559. *
  560. * Called from within an interrupt lock area.
  561. *
  562. * SEE ALSO:
  563. * NOMANUAL
  564. */
  566. void evtLogO
  567.     (
  568.     event_t  action,             /* event action */
  569.     int      nParam,
  570.     int      param1,
  571.     int      param2,
  572.     int      param3,
  573.     int      param4,
  574.     int      param5
  575.     )
  576.     {
  577.     event_t *       eventBase;
  578.     int *            intBase;
  579.     int      timestamp;
  581.     EVTLOG_RESERVE_BUFF_SPACE_L(6 + (nParam * 4));
  583.     EVT_STORE_UINT16 (eventBase, action);
  584.     intBase = (int *) eventBase;
  585.     timestamp = (* _func_tmrStamp) ();
  586.     EVT_STORE_UINT32 (intBase, timestamp);
  588.     switch (nParam)
  589.         {
  590.         case 5:
  591.             EVT_STORE_UINT32 (intBase, param5);
  593.         case 4:
  594.             EVT_STORE_UINT32 (intBase, param4);
  596.         case 3:
  597.             EVT_STORE_UINT32 (intBase, param3);
  599.         case 2:
  600.             EVT_STORE_UINT32 (intBase, param2);
  602.         case 1:
  603.             EVT_STORE_UINT32 (intBase, param1);
  604.         }
  605.     }
  607. /*******************************************************************************
  608. *
  609. * evtLogString - Add a string to the event log.
  610. *
  611. * This event logging routine stores
  612. * event id (short )
  613. * arg (int)
  614. * arg (int)
  615. * arg (int)
  616. * address (int)
  617. * string size (int)   - if size is ZERO the string does not exist.
  618. * string (char)
  619. *
  620. * SEE ALSO:
  621. * NOMANUAL
  622. */
  624. void evtLogString
  625.     (
  626.     event_t       action, /* the event id */
  627.     int              arg1, /* an extra argument */
  628.     int              arg2, /* an extra argument */
  629.     int              arg3, /* an extra argument */
  630.     int              addrId, /* an address */
  631.     const char *     string /* series of characters */
  632.     )
  633.     {
  634.     event_t *        eventBase;
  635.     int *            intBase;
  636.     int              evtSize = strlen (string);
  637.     int              level;
  639.     evtSize = MEM_ROUND_UP (evtSize);
  641.     level = intLock ();                 /* LOCK INTERRUPTS */
  643.     EVTLOG_RESERVE_BUFF_SPACE(evtSize + EVTLOG_STR_SIZE);
  645.     EVT_STORE_UINT16 (eventBase, action);
  646.     intBase = (int *) eventBase;
  647.     EVT_STORE_UINT32 (intBase, arg1);
  648.     EVT_STORE_UINT32 (intBase, arg2);
  649.     EVT_STORE_UINT32 (intBase, arg3);
  650.     EVT_STORE_UINT32 (intBase, addrId);
  651.     EVT_STORE_UINT32 (intBase, evtSize);
  653.     if (evtSize != 0)
  654. {
  655.         strncpy ((char *) intBase, string, evtSize);
  656. }
  658.     intUnlock (level);                  /* UNLOCK INTERRUPTS */
  659.     }
  661. /*******************************************************************************
  662. *
  663. * evtLogPoint - logs a user defined event or eventpoint via event () or e ().
  664. *
  665. * This event logging routine stores
  666. * event id (short )
  667. * timestamp (int)
  668. * address (int)
  669. * buffer size (int) - if size is ZERO the buffer does not exist.
  670. * buffer (char)
  671. *
  672. * RETURNS: OK, or ERROR if unable to log event point
  673. * SEE ALSO:
  674. * NOMANUAL
  675. */
  677. STATUS evtLogPoint 
  678.     (
  679.     event_t    action, /* event id */
  680.     void *     addr,  /* pc address */
  681.     size_t     nbytes, /* buffer size */
  682.     char *     buffer /* buffer */
  683.     )
  684.     {
  685.     event_t *        eventBase;
  686.     event_t       biasedAction;
  687.     int *       intBase;
  688.     int       level;
  689.     int       timestamp;
  691.     biasedAction = action + MIN_USER_ID;
  693.     /* if (evtLogTIsOn) */
  694. {
  696.         /* is event id within the range of user event ids? */
  697.         if (biasedAction < MIN_USER_ID || biasedAction > MAX_USER_ID)
  698.     return (ERROR);
  700.         level = intLock ();                 /* LOCK INTERRUPTS */
  702.         EVTLOG_RESERVE_BUFF_SPACE_STAT(nbytes + EVTLOG_PT_SIZE);
  704.         EVT_STORE_UINT16 (eventBase, biasedAction);
  705.         intBase = (int *) eventBase;
  706.         timestamp = (* _func_tmrStamp) ();
  707. EVT_STORE_UINT32 (intBase, timestamp);
  708.         EVT_STORE_UINT32 (intBase, (int) addr);
  709.         EVT_STORE_UINT32 (intBase, nbytes);
  711. /* copy buffer contents into event buffer */
  713.         if ((nbytes != 0) && (buffer != NULL))
  714.     {
  715.     memcpy ((char *) intBase, buffer, nbytes);
  716.     }
  718.         intUnlock (level);                  /* UNLOCK INTERRUPTS */
  719.         }
  720.     return (OK);
  721.     }
  723. /*******************************************************************************
  724. *
  725. * evtLogTasks - log name, status and priority of all tasks in the system
  726. *
  727. * SEE ALSO:
  728. * NOMANUAL
  729. */
  731. void evtLogTasks (void)
  732.     {
  733.     int         nTasks;                 /* number of task */
  734.     int         idList[MAX_WV_TASKS];   /* list of active IDs */
  735.     int         ix;                     /* index */
  737.     /* get list of tasks in the system */
  738.     nTasks = taskIdListGet (idList, NELEMENTS (idList));
  740.     /* sort the task list */
  741.     taskIdListSort (idList, nTasks);
  743.     /* log the name of each task in the system */
  744.     for (ix = 0; ix < nTasks; ++ix)
  745.         {
  746.         if (taskIdVerify (idList[ix]) == OK)
  747.             {
  748.             evtLogString (EVENT_TASKNAME, 
  749.              ((WIND_TCB *)idList[ix])->status,
  750.              ((WIND_TCB *)idList[ix])->priority,
  751.              ((WIND_TCB *)idList[ix])->lockCnt,
  752.           idList[ix], taskName (idList[ix]));
  753.     }
  754.         }
  755.     }
  757. /*******************************************************************************
  758. * 
  759. * evtSched - log events from the portable kernel 
  760. *
  761. * This event logging routine stores
  762. *       event id        (short)
  763. * time stamp (int)
  764. * taskIdCurrent   (int) | if event is EVENT_WIND_EXIT_DISPATCH or
  765. * priority (int) | EVENT_WIND_EXIT_NODISPATCH
  766. * directly onto the buffer.
  767. * It is used for the portable workQLib.
  768. * Assume that interrupts are already locked.
  769. *
  770. * SEE ALSO:
  771. * NOMANUAL
  772. */
  774. void evtsched
  775.     (
  776.     event_t action,           /* event id */
  777.     int     arg1,       /* taskIdCurrent or not logged */
  778.     int     arg2       /* priority or not logged */
  779.     )
  780.     {
  781.     event_t *        eventBase;
  782.     int *            intBase;
  783.     int      timestamp;
  785. #if 0 /* need this? NPS */
  787.     if (evtBufOverflow) /* leave if buffer is full */
  788. return;
  789. #endif
  791.     timestamp = (* _func_tmrStamp) ();
  793.     switch (action)
  794.     {
  795.     case EVENT_WIND_EXIT_IDLE: 
  796. {
  797.         EVTLOG_RESERVE_BUFF_SPACE_L(6);
  799.         EVT_STORE_UINT16 (eventBase, action);
  800.         intBase = (int *) eventBase;
  801.         EVT_STORE_UINT32 (intBase, timestamp);
  802. break;
  803. }
  804.     case EVENT_WIND_EXIT_NODISPATCH:
  805.     case EVENT_WIND_EXIT_NODISPATCH_PI:
  806. {
  807.         EVTLOG_RESERVE_BUFF_SPACE_L(10);
  809.         EVT_STORE_UINT16 (eventBase, action);
  810.         intBase = (int *) eventBase;
  811.         EVT_STORE_UINT32 (intBase, timestamp);
  812. EVT_STORE_UINT32 (intBase, arg2); /* priority */
  813. break;
  814. }
  815.     case EVENT_WIND_EXIT_DISPATCH:
  816.     case EVENT_WIND_EXIT_DISPATCH_PI:
  817. {
  818.         EVTLOG_RESERVE_BUFF_SPACE_L(14);
  820.         EVT_STORE_UINT16 (eventBase, action);
  821.         intBase = (int *) eventBase;
  822.         EVT_STORE_UINT32 (intBase, timestamp);
  823. EVT_STORE_UINT32 (intBase, arg1); /* taskIdCurrent */
  824. EVT_STORE_UINT32 (intBase, arg2); /* priority */
  825. }
  826.     }
  827.     }
  829. #if CPU_FAMILY==PPC
  831. /*******************************************************************************
  832. *
  833. * evtLogT1_noTS - log event id without getting timestamp
  834. *
  835. * This event logging routine stores
  836. *       event id        (short )
  837. *       time            (int )
  838. *
  839. * This routines is very similar to the evtLogT1. The main difference
  840. * is that no timestamp is here. The parameter passed is actually the
  841. * current timestamp for this event. This routine is called when an
  842. * interrupt is entered. It is used for PPC architecture. PPC generates
  843. * only one kind of interrupt. When the interrupt is entered, the timestamp
  844. * for windview is obtained. No information about the type of interrupt is
  845. * known at that point. Only when the sysIbcIntHandler routine is called,
  846. * the interrupt vector handler is obtained and it is passed to this
  847. * routine, together with the timestamp.
  848. * When this routine is called, interrupts must be locked already.
  849. *
  850. * SEE ALSO:
  851. * NOMANUAL
  852. */
  854. void evtLogT1_noTS
  855.     (
  856.     event_t action,           /* event id */
  857.     int     param            /* timestamp */
  858.     )
  859.     {
  860.     event_t *        eventBase;
  861.     int *            intBase;
  864.     EVTLOG_RESERVE_BUFF_SPACE_L(EVTLOG_T0_SIZE);
  866.     EVT_STORE_UINT16 (eventBase, action);
  867.     intBase = (int *) eventBase;
  868.     EVT_STORE_UINT32 (intBase, param);
  870.     }
  872. #endif /* CPU_FAMILY==PPC */
  874. #if CPU_FAMILY==I960
  876. /*******************************************************************************
  877. * 
  878. * windInst1 - log events from the 960 assembly language kernel 
  879. *
  880. * Interrupts are locked when this is called
  881. *
  882. * SEE ALSO:
  883. * NOMANUAL
  884. */
  887. void windInst1 (void)
  888.     {
  889.     EVT_CTX_NODISP ((int)taskIdCurrent,
  890.     taskIdCurrent->priority,
  891.     taskIdCurrent->priNormal);
  892.     }
  895. /*******************************************************************************
  896. * 
  897. * windInstDispatch - 
  898. *
  899. * interrupts are locked out when this is called.
  900. *
  901. * SEE ALSO:
  902. * NOMANUAL
  903. */
  906. void windInstDispatch (void)
  907.     {
  908.     /*
  909.      * At this point, we need to decide whether to log an event
  910.      * EVENT_WIND_EXIT_DISPATCH or EVENT_WIND_EXIT_DISPATCH_PI.
  911.      * This is done in the macro EVT_CTX_DISP by comparing
  912.      * taskIdCurrent->priority and taskIdCurrent->priNormal. As
  913.      * a result, the first parameter to the EVT_CTX_DISP macro is
  914.      * not actually used and could be removed in a future code tidy up.
  915.      */
  917.     EVT_CTX_DISP (EVENT_WIND_EXIT_DISPATCH_PI,
  918.   (int) taskIdCurrent, 
  919.   taskIdCurrent->priority, 
  920.   taskIdCurrent->priNormal);
  921.     }
  923. /*******************************************************************************
  924. * 
  925. * windInstIdle - 
  926. *
  927. * interrupts are locked out when this is called.
  928. *
  929. * SEE ALSO:
  930. * NOMANUAL
  931. */
  933. void windInstIdle (void)
  934.     {
  935.     EVT_CTX_IDLE(EVENT_WIND_EXIT_IDLE, &readyQHead);
  936.     }
  938. /*******************************************************************************
  939. * 
  940. * windInstIntEnt -
  941. *
  942. * Interrupts are NOT locked when this is called.
  943. * evtAction has already been checked for non-zero.
  944. *
  945. * SEE ALSO:
  946. * NOMANUAL
  947. */
  949. void windInstIntEnt (void)
  950.     {
  951.     int  level;
  952.     event_t evtId;
  954.     /* 
  955.      * shift and mask off bits returned by intLock to obtain
  956.      * I960 specific interrupt level. Then convert to event ID
  957.      */
  959.     level = intLock ();
  960.     evtId = (event_t) EVENT_INT_ENT ((level >> 16) & 0x001f);
  962.     if ( WV_EVTCLASS_IS_SET(WV_CLASS_1|WV_ON) )
  963. ( * _func_evtLogT0_noInt) (evtId);
  965.     intUnlock (level);
  967.     if (TRG_EVTCLASS_IS_SET(TRG_CLASS_1|TRG_ON))
  968. ( * _func_trgCheck) (evtId, TRG_CLASS1_INDEX, 
  969.                      NULL, NULL, NULL, NULL, NULL, NULL);
  970.     }
  972. /*******************************************************************************
  973. * 
  974. * windInstIntExit -
  975. *
  976. * Interrupts are NOT locked when this is called.
  977. * evtAction has already been checked for non-zero.
  978. *
  979. * SEE ALSO:
  980. * NOMANUAL
  981. */
  983. void windInstIntExit (void)
  984.     {
  985.     int  level;
  986.     event_t evtId;
  988.     level = intLock ();
  989.     
  990.     if (workQIsEmpty)
  991.      evtId = EVENT_INT_EXIT;
  992.     else
  993.      evtId = EVENT_INT_EXIT_K;
  995.     if ( WV_EVTCLASS_IS_SET(WV_CLASS_1|WV_ON) )
  996. ( * _func_evtLogT0_noInt) (evtId);
  998.     intUnlock (level);
  1000.     if (TRG_EVTCLASS_IS_SET(TRG_CLASS_1|TRG_ON))
  1001. ( * _func_trgCheck) (evtId, TRG_CLASS1_INDEX, 
  1002.                      NULL, NULL, NULL, NULL, NULL, NULL);
  1003.     }
  1005. #endif /* CPU_FAMILY==I960 */