home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ddkx86v5.zip / DDKX86 / SRC / DEV / DASD / OS2DASD / DMTRACE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-14  |  31.7 KB  |  977 lines
  1. /*DDK*************************************************************************/
  2. /*                                                                           */
  3. /* COPYRIGHT    Copyright (C) 1995 IBM Corporation                           */
  4. /*                                                                           */
  5. /*    The following IBM OS/2 WARP source code is provided to you solely for  */
  6. /*    the purpose of assisting you in your development of OS/2 WARP device   */
  7. /*    drivers. You may use this code in accordance with the IBM License      */
  8. /*    Agreement provided in the IBM Device Driver Source Kit for OS/2. This  */
  9. /*    Copyright statement may not be removed.                                */
  10. /*                                                                           */
  11. /*****************************************************************************/
  12. /*static char *SCCSID = "%w% %e%";*/
  13. #define SCCSID  "%w% %e%"
  14.  
  15. /**************************************************************************
  16.  *
  17.  * SOURCE FILE NAME = DMTRACE.C
  18.  *
  19.  * DESCRIPTIVE NAME = OS2DASD.DMD - OS/2 DASD Device Manager
  20.  *
  21.  *
  22.  *
  23.  * VERSION = V2.0
  24.  *
  25.  * DATE
  26.  *
  27.  * DESCRIPTION : Perfview/System Tracing routines for OS/2 DASD Mgr
  28.  *
  29.  *
  30.  *
  31. */
  32. #include "dmh.h"
  33. #include "infoseg.h"
  34. #include "perfhook.h"
  35.  
  36. VOID   Initialize_PFV();                                             /*@V55646*/
  37. VOID   TraceStrat1Pre (USHORT, PBYTE, NPVOLCB);
  38. VOID   TraceStrat1Post (USHORT, PBYTE);
  39. VOID   TraceStrat2Pre (USHORT, PBYTE, NPVOLCB);
  40. VOID   TraceStrat2Post (USHORT, PBYTE);
  41. VOID   TraceIORBPre (USHORT, PBYTE, NPUNITCB);
  42. VOID   TraceIORBPost (USHORT, PBYTE, NPUNITCB);
  43. VOID   TraceIORBDekkoPre (USHORT, PBYTE);
  44. USHORT GetTraceType (USHORT, PBYTE);
  45. USHORT GetCmdString (USHORT);
  46. VOID   DekkoTrace (USHORT, USHORT, PBYTE);
  47. VOID   PerfViewTrace (USHORT, PBYTE, NPUNITCB);
  48. VOID   TraceIORBInternal (USHORT, PBYTE);
  49. USHORT IsTraceOn2(VOID);                                             /*@V81576*/
  50.  
  51. extern USHORT   PerfViewInstalled;                                   /*@V81576*/
  52.  
  53. #define PFV_Active 1                                                 /*@V55646*/
  54.  
  55. typedef struct InfoSegGDT FAR *PInfoSegGDT;
  56.  
  57. typedef struct _TRACEENTRY
  58. {
  59.    UCHAR  TraceData[32];
  60.  
  61. } TRACEENTRY, FAR *PTRACEENTRY;
  62. /*------------------------------------------------------------------------
  63. ;
  64. ;** IsTraceOn - Checks to see if RAS/DEKKO/PERFVIEW/Internal trace is
  65. ;               enabled and sets the appropriate flag bits in the
  66. ;               global TraceFlags variable.
  67. ;
  68. ;   USHORT IsTraceOn ()
  69. ;
  70. ;   ENTRY: VOID
  71. ;
  72. ;   RETURN:   USHORT            TraceFlags
  73. ;
  74. ;   EFFECTS:
  75. ;
  76. ------------------------------------------------------------------------*/
  77. USHORT IsTraceOn ()
  78.  
  79. {
  80.    if (DDFlags & DDF_INIT_TIME)
  81.       return(0);
  82.  
  83.    if ( DDFlags & DDF_DISCARD_TRACE )                                /*@V81576*/
  84.       return(0);                                                     /*@V81576*/
  85.                                                                      /*@V81576*/
  86.    return ( IsTraceOn2() );                                          /*@V81576*/
  87. }                                                                    /*@V81576*/
  88.  
  89.  
  90. /*-----------------------------------------------------------------
  91. ;
  92. ;** IsTraceNeeded -
  93. ;
  94. ------------------------------------------------------------------*/
  95.                                                                      /*@V81576*/
  96. USHORT IsTraceNeeded()                                               /*@V81576*/
  97. {                                                                    /*@V81576*/
  98.   return( IsTraceOn2() || PerfViewInstalled );                       /*@V81576*/
  99. }                                                                    /*@V81576*/
  100.  
  101.  
  102. /*------------------------------------------------------------------------
  103. ;
  104. ;** IsTraceOn2 - Checks to see if RAS/DEKKO/PERFVIEW/Internal trace is
  105. ;
  106. ------------------------------------------------------------------------*/
  107.  
  108. USHORT IsTraceOn2()                                                  /*@V81576*/
  109. {
  110.    DISABLE;
  111.  
  112.    TraceFlags &= ~(TF_DEKKO | TF_RAS | TF_PERFVIEW);
  113.  
  114.    /* First see if DEKKO tracing is required */
  115.  
  116.    if ( TEST_TRACING(pSIS_mec_table, DEKKO_MAJOR_DISK) )
  117.       TraceFlags |= TF_DEKKO;
  118.  
  119.    /* Else see if RAS Tracing is required */
  120.  
  121.    else if ( TEST_RAS_TRACING(pSIS_mec_table, RAS_MAJOR_DISK) )
  122.       TraceFlags |= TF_RAS;
  123.  
  124.    /* See if PerfView Tracing is enabled */
  125.    if ( (pVolCB_80 != 0) &&
  126.         (pVolCB_80->pUnitCB->PerfViewDB.pfdbh.dbh_pfnTmrAdd != 0) )
  127.       TraceFlags |= TF_PERFVIEW;
  128.  
  129.    if (!(TraceFlags & TF_PERFVIEW))                                  /*@V55646*/
  130.      PFV_PreviousState &= ~PFV_Active;                               /*@V55646*/
  131.  
  132.    ENABLE;
  133.  
  134.    return(TraceFlags);
  135. }
  136.  
  137. /*------------------------------------------------------------------------
  138. ;
  139. ;** Trace - RAS/DEKKO/PERFVIEW/Internal Tracing Functions
  140. ;
  141. ;   Checks to see if RAS/DEKKO/PERFVIEW/Internal Tracing is enabled
  142. ;   and performs the requested tracing function.
  143. ;
  144. ;   USHORT Trace (USHORT TraceFlags, PBYTE pRequest, NPVOLCB pVolCB)
  145. ;
  146. ;   ENTRY:    TraceEvent       - Trace Event Flags
  147. ;             pRequest         - Request to trace
  148. ;             pVolCB           - Trace Point
  149. ;
  150. ;   RETURN:   VOID
  151. ;
  152. ;   EFFECTS:
  153. ;
  154. ------------------------------------------------------------------------*/
  155. VOID Trace (TraceEvent, pRequest, pVolCB)
  156.  
  157. USHORT  TraceEvent;
  158. PBYTE   pRequest;
  159. NPVOLCB pVolCB;
  160.  
  161. {
  162.    USHORT TraceType;
  163.  
  164.    if (DDFlags & DDF_INIT_TIME)
  165.       return;
  166.  
  167.    if (TraceEvent & TRACE_STRAT1)
  168.    {
  169.       if ( TraceFlags & (TF_DEKKO | TF_RAS) )
  170.       {
  171.          if ((TraceType = GetTraceType(TraceEvent, pRequest)) == 0)
  172.             return;
  173.  
  174.          TraceEvent |= TraceType;
  175.  
  176.          if (TraceEvent & TRACE_ENTRY)
  177.             TraceStrat1Pre(TraceEvent, pRequest, pVolCB);
  178.          else
  179.             TraceStrat1Post(TraceEvent, pRequest);
  180.       }
  181.    }
  182.    else if (TraceEvent & TRACE_STRAT2)
  183.    {
  184.       if ( TraceFlags & (TF_DEKKO | TF_RAS) )
  185.       {
  186.          if (TraceEvent & TRACE_ENTRY)
  187.             TraceStrat2Pre(TraceEvent, pRequest, pVolCB);
  188.          else
  189.             TraceStrat2Post(TraceEvent, pRequest);
  190.       }
  191.    }
  192.    else if (TraceEvent & TRACE_IORB)
  193.    {
  194.       if (TraceFlags & TF_INTERNAL)
  195.          TraceIORBInternal(TraceEvent, pRequest);
  196.  
  197.       if ((TraceType = GetTraceType(TraceEvent, pRequest)) == 0)
  198.          return;
  199.  
  200.       TraceEvent |= TraceType;
  201.  
  202.       if ( TraceFlags & (TF_DEKKO | TF_RAS | TF_PERFVIEW) )
  203.       {
  204.          if (TraceEvent & TRACE_ENTRY)
  205.             TraceIORBPre(TraceEvent, pRequest, (NPUNITCB) pVolCB);
  206.          else
  207.             TraceIORBPost(TraceEvent, pRequest, (NPUNITCB) pVolCB);
  208.       }
  209.    }
  210. }
  211.  
  212. /*------------------------------------------------------------------------
  213. ;
  214. ;** TraceStrat1Pre - Trace Strategy-1 Pre-Invocation Request
  215. ;
  216. ;   VOID TraceStrat1Request (USHORT TraceEvent, PBYTE pRequest, pVolCB)
  217. ;
  218. ;   ENTRY:    TraceEvent       - Trace Flags
  219. ;             pRequest         - Request to trace
  220. ;             pVolCB           - Pointer to VolCB
  221. ;
  222. ;   RETURN:   VOID
  223. ;
  224. ;   EFFECTS:
  225. ;
  226. ------------------------------------------------------------------------*/
  227. VOID TraceStrat1Pre (TraceEvent, pRequest, pVolCB)
  228.  
  229. USHORT  TraceEvent;
  230. PBYTE   pRequest;
  231. NPVOLCB pVolCB;
  232.  
  233. {
  234.    UCHAR  TraceBuffer[sizeof(TCB)];
  235.    PTCB   pTraceBuffer = (PTCB) TraceBuffer;
  236.    USHORT MinorCode = 0;
  237.    PBYTE  pPkt;
  238.  
  239.    if (((PRPH)pRequest)->Flags & RPF_Internal)
  240.       return;
  241.  
  242.    pTraceBuffer->pRequest = pRequest;
  243.    pTraceBuffer->Unit = pVolCB->pUnitCB->PhysDriveNum;
  244.  
  245.    if ( ((PRPH)pRequest)->Unit <= 26)
  246.       (USHORT) pTraceBuffer->Drive[0] = (USHORT) (((PRPH)pRequest)->Unit + 'A');
  247.    else
  248.       (USHORT) pTraceBuffer->Drive[0] = ' ';
  249.    pTraceBuffer->Drive[1] = 0;
  250.  
  251.    pTraceBuffer->CommandCode = ((PRPH)pRequest)->Cmd;
  252.    (USHORT) (pTraceBuffer->CmdString[0]) = GetCmdString(TraceEvent);
  253.    pTraceBuffer->CmdString[2]=0;
  254.    pTraceBuffer->RequestControl=0;
  255.    pTraceBuffer->Priority = 3;
  256.    pTraceBuffer->Flags=0;
  257.    pTraceBuffer->cSGList = 1;
  258.    pTraceBuffer->pRLH = 0;
  259.  
  260.    pTraceBuffer->RBA = ((PRP_RWV)pRequest)->rba + pVolCB->PartitionOffset +
  261.                          pVolCB->MediaBPB.HiddenSectors;
  262.  
  263.    pTraceBuffer->BlockCount = (ULONG) ((PRP_RWV)pRequest)->NumSectors;
  264.  
  265.    MinorCode = RAS_MINOR_STRAT1_RWV;
  266.  
  267.    if (TraceEvent & TRACE_IOCTL)
  268.    {
  269.        MinorCode = RAS_MINOR_IOCTL_RWVF;
  270.        pTraceBuffer->CommandCode = ((PRP_GENIOCTL)pRequest)->Category;
  271.        pTraceBuffer->CommandModifier = ((PRP_GENIOCTL)pRequest)->Function;
  272.  
  273.        if ( ((PRP_GENIOCTL)pRequest)->Category == 9)
  274.        {
  275.           pTraceBuffer->Unit |= 0x80;
  276.           pTraceBuffer->Drive[0]=' ';
  277.        }
  278.  
  279.        pPkt = ((PRP_GENIOCTL)pRequest)->ParmPacket;
  280.        (USHORT) pTraceBuffer->RBA = ((PDDI_RWVPacket_param)pPkt)->Cylinder;
  281.        SELECTOROF(pTraceBuffer->RBA) = ((PDDI_RWVPacket_param)pPkt)->Head;
  282.  
  283.        pTraceBuffer->BlockCount = ((PDDI_RWVPacket_param)pPkt)->NumSectors;
  284.  
  285.        if (TraceEvent & TRACE_FORMAT)
  286.        {
  287.            pPkt = ((PRP_GENIOCTL)pRequest)->ParmPacket;
  288.  
  289.            if ( ((PDDI_FormatPacket_param)pPkt)->NumTracks != 0)
  290.            {
  291.                pTraceBuffer->BlockCount =
  292.                           (ULONG) ((PDDI_FormatPacket_param)pPkt)->NumTracks;
  293.                pTraceBuffer->CmdString[0]='M';
  294.            }
  295.        }
  296.    }
  297.  
  298.    if (TraceFlags & TF_RAS)
  299.       DevHelp_RAS(RAS_MAJOR_DISK, MinorCode, sizeof(TCB), (PBYTE) pTraceBuffer);
  300.    else
  301.       DekkoTrace(MinorCode, sizeof(TCB), (PBYTE) pTraceBuffer);
  302.  
  303.    return;
  304. }
  305. /*------------------------------------------------------------------------
  306. ;
  307. ;** TraceStrat1Post - Trace Strategy-1 Post-Invocation Request
  308. ;
  309. ;   VOID TraceStrat1Post (USHORT TraceEvent, PBYTE pRequest)
  310. ;
  311. ;   ENTRY:    TraceEvent       - Trace Flags
  312. ;             pRequest         - Request to trace
  313. ;
  314. ;   RETURN:   VOID
  315. ;
  316. ;   EFFECTS:
  317. ;
  318. ------------------------------------------------------------------------*/
  319. VOID TraceStrat1Post (TraceEvent, pRequest)
  320.  
  321. USHORT TraceEvent;
  322. PBYTE  pRequest;
  323.  
  324. {
  325.    UCHAR  TraceBuffer[sizeof(TCBD)];
  326.    PTCBD  pTraceBuffer = (PTCBD) TraceBuffer;
  327.    USHORT MinorCode = 0;
  328.  
  329.    if (((PRPH)pRequest)->Flags & (RPF_TraceComplete | RPF_Internal))
  330.       return;
  331.  
  332.    ((PRPH)pRequest)->Flags |= RPF_TraceComplete;
  333.  
  334.    pTraceBuffer->pRequest = pRequest;
  335.    pTraceBuffer->Status = (USHORT) (((PRPH)pRequest)->Status >> 8);
  336.    pTraceBuffer->ErrorCode = (USHORT) (((PRPH)pRequest)->Status & 0x00FF);
  337.    pTraceBuffer->BlocksXferred = (ULONG) ((PRP_RWV)pRequest)->NumSectors;
  338.  
  339.    MinorCode = RAS_MINOR_STRAT1_RWV;
  340.    if ( ((PRPH)pRequest)->Cmd == CMDGenIOCTL )
  341.       MinorCode = RAS_MINOR_IOCTL_RWVF;
  342.  
  343.    if (TraceFlags & TF_RAS)
  344.    {
  345.      MinorCode |= 0x0080;                                            /*@V64478*/
  346.      DevHelp_RAS(RAS_MAJOR_DISK, MinorCode, sizeof(TCBD), (PBYTE) pTraceBuffer);
  347.    }
  348.    else
  349.    {
  350.      MinorCode |= 0x0080;
  351.      DekkoTrace(MinorCode, sizeof(TCBD), (PBYTE) pTraceBuffer);
  352.    }
  353. }
  354.  
  355.  
  356.  
  357. /*------------------------------------------------------------------------
  358. ;
  359. ;** TraceStrat2Pre - Trace Strategy-2 Pre-Invocation
  360. ;
  361. ;   VOID TraceStrat2Pre  (USHORT TraceEvent, PBYTE pRequest, pVolCB)
  362. ;
  363. ;   ENTRY:    TraceEvent       - Trace flags
  364. ;             pRequest         - Request to trace
  365. ;             pVolCB           - pointer to VolCB
  366. ;
  367. ;   RETURN:   VOID
  368. ;
  369. ;   EFFECTS:
  370. ;
  371. ------------------------------------------------------------------------*/
  372. VOID TraceStrat2Pre (TraceEvent, pRequest, pVolCB)
  373.  
  374. USHORT     TraceEvent;
  375. PBYTE      pRequest;
  376. NPVOLCB    pVolCB;
  377.  
  378. {
  379.    UCHAR  TraceBuffer[sizeof(TCB)];
  380.    PTCB   pTraceBuffer = (PTCB) TraceBuffer;
  381.    USHORT i, Count, TraceType;
  382.    UCHAR  UnitChar;
  383.    PPB_Read_Write  pPkt;
  384.  
  385.    /* Trace Request List Header */
  386.  
  387.    ((PTRLHS)pTraceBuffer)->pRLH = pRequest;
  388.    ((PTRLHS)pTraceBuffer)->Count =  ((PReq_List_Header)pRequest)->Count;
  389.    ((PTRLHS)pTraceBuffer)->Unit = pVolCB->pUnitCB->PhysDriveNum;
  390.  
  391.    UnitChar = ' ';
  392.    if ( ((PReq_List_Header)pRequest)->Block_Dev_Unit <= 26 )
  393.      UnitChar=(UCHAR)(((PReq_List_Header)pRequest)->Block_Dev_Unit+(UCHAR)'A');
  394.  
  395.    (USHORT) ((PTRLHS)pTraceBuffer)->Drive[0] = (USHORT) UnitChar;
  396.  
  397.    ((PTRLHS)pTraceBuffer)->Request_Control =
  398.                             ((PReq_List_Header)pRequest)->Request_Control;
  399.  
  400.    if (TraceFlags & TF_RAS)
  401.      DevHelp_RAS(RAS_MAJOR_DISK, RAS_MINOR_STRAT2_RLH, sizeof(TRLHS),
  402.                                                  (PBYTE) pTraceBuffer);
  403.    else
  404.      DekkoTrace(RAS_MINOR_STRAT2_RLH, sizeof(TRLHS), (PBYTE) pTraceBuffer);
  405.  
  406.    /* Trace each request entry */
  407.  
  408.    Count = ((PReq_List_Header)pRequest)->Count;
  409.    pPkt = (PPB_Read_Write) ((PBYTE)pRequest+sizeof(Req_List_Header));
  410.  
  411.    for (i = 0; i < Count; i++)
  412.    {
  413.       pTraceBuffer->Unit = pVolCB->pUnitCB->PhysDriveNum;
  414.       (USHORT) pTraceBuffer->Drive[0] = (USHORT) UnitChar;
  415.       pTraceBuffer->CommandCode = pPkt->RqHdr.Command_Code;
  416.  
  417.       if ((TraceType = GetTraceType(TraceEvent, (PBYTE) pPkt)) == 0)
  418.          return;
  419.       TraceEvent |= TraceType;
  420.  
  421.       (USHORT) (pTraceBuffer->CmdString[0]) = GetCmdString(TraceEvent);
  422.       pTraceBuffer->CmdString[2]=0;
  423.  
  424.       pTraceBuffer->RequestControl = pPkt->RqHdr.Req_Control;
  425.       pTraceBuffer->Priority = pPkt->RqHdr.Priority;
  426.       pTraceBuffer->pRequest = (PBYTE) pPkt;
  427.       pTraceBuffer->pRLH = OFFSETOF(pRequest);
  428.       pTraceBuffer->cSGList = pPkt->SG_Desc_Count;
  429.       pTraceBuffer->RBA = pPkt->Start_Block + pVolCB->PartitionOffset +
  430.                                  pVolCB->MediaBPB.HiddenSectors;
  431.       pTraceBuffer->BlockCount = pPkt->Block_Count;
  432.  
  433.       OFFSETOF(pPkt) = OFFSETOF(pPkt) + pPkt->RqHdr.Length;
  434.  
  435.       if (TraceFlags & TF_RAS)
  436.          DevHelp_RAS(RAS_MAJOR_DISK, RAS_MINOR_STRAT2_RLE,
  437.                                      sizeof(TCB), (PBYTE) pTraceBuffer);
  438.       else
  439.          DekkoTrace(RAS_MINOR_STRAT2_RLE, sizeof(TCB), (PBYTE) pTraceBuffer);
  440.    }
  441. }
  442. /*------------------------------------------------------------------------
  443. ;
  444. ;** TraceStrat2Post - Trace Strategy-2 Post-Invocation
  445. ;
  446. ;   VOID TraceStrat2Post (USHORT TraceEvent, PBYTE pRequest)
  447. ;
  448. ;   ENTRY:    TraceEvent       - Trace flags
  449. ;             pRequest         - Request to trace
  450. ;
  451. ;   RETURN:   VOID
  452. ;
  453. ;   EFFECTS:
  454. ;
  455. ------------------------------------------------------------------------*/
  456. VOID TraceStrat2Post (TraceEvent, pRequest)
  457.  
  458. USHORT     TraceEvent;
  459. PBYTE      pRequest;
  460.  
  461. {
  462.    UCHAR  TraceBuffer[sizeof(TCBD)];
  463.    PTCBD  pTraceBuffer = (PTCBD) TraceBuffer;
  464.  
  465.    if ( TraceEvent & TRACE_RLE )                                     /*@V85908*/
  466.    {                                                                 /*@V85908*/
  467.       pTraceBuffer->pRequest = pRequest;
  468.       pTraceBuffer->Status = (USHORT)((PPB_Read_Write)pRequest)->RqHdr.Status;
  469.       pTraceBuffer->ErrorCode=(USHORT)((PPB_Read_Write)pRequest)->RqHdr.Error_Code;
  470.       pTraceBuffer->BlocksXferred = ((PPB_Read_Write)pRequest)->Blocks_Xferred;
  471.  
  472.       if (TraceFlags & TF_RAS)
  473.         DevHelp_RAS(RAS_MAJOR_DISK, RAS_MINOR_STRAT2_RLE | 0x0080,   /*@V64478*/
  474.                                     sizeof(TCBD), (PBYTE) pTraceBuffer);
  475.       else
  476.         DekkoTrace(RAS_MINOR_STRAT2_RLE | 0x80, sizeof(TCBD), (PBYTE)pTraceBuffer);
  477.  
  478.    }                                                                 /*@V85908*/
  479.    else                                                              /*@V85908*/
  480.    {                                                                 /*@V85908*/
  481.       /* If we're done with the list, then trace the RLH post */
  482.  
  483.       if ( ((PReq_List_Header)pRequest)->Lst_Status & RLH_All_Req_Done )
  484.       {
  485.          ((PTRLHD)pTraceBuffer)->pRLH = pRequest;
  486.          ((PTRLHD)pTraceBuffer)->DoneCount =
  487.                                  ((PReq_List_Header)pRequest)->y_Done_Count;
  488.          ((PTRLHD)pTraceBuffer)->Status =
  489.                                (USHORT) ((PReq_List_Header)pRequest)->Lst_Status;
  490.  
  491.          if (TraceFlags & TF_RAS)
  492.            DevHelp_RAS(RAS_MAJOR_DISK, RAS_MINOR_STRAT2_RLH | 0x0080,/*@V64478*/
  493.                                     sizeof(TRLHD), (PBYTE) pTraceBuffer);
  494.          else
  495.            DekkoTrace(RAS_MINOR_STRAT2_RLH | 0x80,sizeof(TRLHD),
  496.                                              (PBYTE)pTraceBuffer);
  497.       }
  498.    }                                                                 /*@V85908*/
  499. }
  500.  
  501.  
  502. /*------------------------------------------------------------------------
  503. ;
  504. ;** TraceIORBPre  - Trace IORB Pre_Invocation Request
  505. ;
  506. ;   VOID TraceIORBPre (USHORT TraceEvent, PBYTE pRequest)
  507. ;
  508. ;   ENTRY:    TraceEvent       - Trace Flags
  509. ;             pRequest         - Request to trace
  510. ;
  511. ;   RETURN:   VOID
  512. ;
  513. ;   EFFECTS:
  514. ;
  515. ------------------------------------------------------------------------*/
  516. VOID TraceIORBPre (TraceEvent, pRequest, pUnitCB)
  517.  
  518. USHORT     TraceEvent;
  519. PBYTE      pRequest;
  520. NPUNITCB   pUnitCB;
  521.  
  522. {
  523.    UCHAR  TraceBuffer[sizeof(TCB)];
  524.    PTCB   pTraceBuffer = (PTCB) TraceBuffer;
  525.    PBYTE  pPkt;
  526.    USHORT TraceType;
  527.  
  528. TraceNextIORB:
  529.    (NPIORB_DMWORK) pPkt = (NPIORB_DMWORK) &(((NPIORB)pRequest)->DMWorkSpace[0]);
  530.    pTraceBuffer->pRequest = ((NPIORB_DMWORK)pPkt)->pRequest;
  531.    pTraceBuffer->Unit = ((NPIORB_DMWORK)pPkt)->pUnitCB->PhysDriveNum;
  532.    pTraceBuffer->RequestControl = ((NPIORB)pRequest)->RequestControl;
  533.    pTraceBuffer->CommandCode = (UCHAR) ((NPIORB)pRequest)->CommandCode;
  534.    pTraceBuffer->CommandModifier= (UCHAR) ((NPIORB)pRequest)->CommandModifier;
  535.  
  536.  
  537.    if ((TraceType = GetTraceType(TraceEvent, pRequest)) == 0)
  538.       return;
  539.    TraceEvent |= TraceType;
  540.  
  541.    (USHORT) (pTraceBuffer->CmdString[0]) = GetCmdString(TraceEvent);
  542.    pTraceBuffer->CmdString[2]=0;
  543.  
  544.     switch( ((NPIORB)pRequest)->CommandCode )
  545.     {
  546.        case IOCC_EXECUTE_IO:
  547.           pTraceBuffer->cSGList = ((NPIORB_EXECUTEIO)pRequest)->cSGList;
  548.           pTraceBuffer->RBA = ((NPIORB_EXECUTEIO)pRequest)->RBA;
  549.           pTraceBuffer->BlockCount=((NPIORB_EXECUTEIO)pRequest)->BlockCount;
  550.           break;
  551.  
  552.        case IOCC_FORMAT:
  553.           pTraceBuffer->cSGList = ((NPIORB_FORMAT)pRequest)->cSGList;
  554.           (PBYTE) pPkt = ((NPIORB_FORMAT)pRequest)->pFormatCmd;
  555.           pTraceBuffer->RBA = ((NPFORMAT_CMD_TRACK)pPkt)->RBA;
  556.           pTraceBuffer->BlockCount =
  557.                         (ULONG) ((NPFORMAT_CMD_TRACK)pPkt)->cTrackEntries;
  558.           pTraceBuffer->Flags = (UCHAR) ((NPFORMAT_CMD_TRACK)pPkt)->Flags;
  559.           break;
  560.  
  561.     }
  562.     if (TraceFlags & TF_RAS)
  563.      DevHelp_RAS(RAS_MAJOR_DISK,RAS_MINOR_IORB,sizeof(TCB),(PBYTE)pTraceBuffer);
  564.     else if (TraceFlags & TF_DEKKO)
  565.      DekkoTrace(RAS_MINOR_IORB, sizeof(TCB), (PBYTE) pTraceBuffer);
  566.     else if (TraceFlags & TF_PERFVIEW)
  567.      PerfViewTrace (TraceEvent, pRequest, pUnitCB);
  568.  
  569.     if  ( ((NPIORB)pRequest)->RequestControl & IORB_CHAIN )
  570.     {
  571.        pRequest = (PBYTE) ((NPIORB)pRequest)->pNxtIORB;
  572.        goto TraceNextIORB;
  573.     }
  574. }
  575. /*------------------------------------------------------------------------
  576. ;
  577. ;** TraceIORBDekkoPre  - Trace IORB Dekko Pre_Invocation Request
  578. ;
  579. ;   VOID TraceIORBDekkoPre (USHORT TraceEvent, PBYTE pRequest)
  580. ;
  581. ;   ENTRY:    TraceEvent       - Trace Flags
  582. ;             pRequest         - Request to trace
  583. ;
  584. ;   RETURN:   VOID
  585. ;
  586. ;   EFFECTS:
  587. ;
  588. ------------------------------------------------------------------------*/
  589. VOID TraceIORBDekkoPre (TraceEvent, pRequest)
  590.  
  591. USHORT     TraceEvent;
  592. PBYTE      pRequest;
  593.  
  594. {
  595.    UCHAR  TraceBuffer[4];
  596.    PTCB   pTraceBuffer = (PTCB) TraceBuffer;
  597.    PBYTE  pPkt;
  598.  
  599.    (NPIORB_DMWORK) pPkt = (NPIORB_DMWORK) &(((NPIORB)pRequest)->DMWorkSpace[0]);
  600.    pTraceBuffer->pRequest = ((NPIORB_DMWORK)pPkt)->pRequest;
  601.    DekkoTrace(RAS_MINOR_IORB, sizeof(TraceBuffer), (PBYTE) pTraceBuffer);
  602.  
  603. }
  604.  
  605.  
  606. /*------------------------------------------------------------------------
  607. ;
  608. ;** TraceIORBPost - Trace IORB Post_Invocation Request
  609. ;
  610. ;   VOID TraceIORBPost (USHORT TraceEvent, PBYTE pRequest, pCB)
  611. ;
  612. ;   ENTRY:    TraceEvent       - Trace Flags
  613. ;             pRequest         - Request to trace
  614. ;
  615. ;   RETURN:   VOID
  616. ;
  617. ;   EFFECTS:
  618. ;
  619. ------------------------------------------------------------------------*/
  620. VOID TraceIORBPost (TraceEvent, pRequest, pUnitCB)
  621.  
  622. USHORT     TraceEvent;
  623. PBYTE      pRequest;
  624. NPUNITCB   pUnitCB;
  625.  
  626. {
  627.    UCHAR  TraceBuffer[sizeof(TCBD)];
  628.    PTCBD  pTraceBuffer = (PTCBD) TraceBuffer;
  629.    PBYTE  pPkt;
  630.  
  631.    (NPIORB_DMWORK) pPkt = (NPIORB_DMWORK) &(((NPIORB)pRequest)->DMWorkSpace[0]);
  632.    pTraceBuffer->pRequest = ((NPIORB_DMWORK)pPkt)->pRequest;
  633.    pTraceBuffer->Status = ((NPIORB)pRequest)->Status;
  634.    pTraceBuffer->ErrorCode = ((NPIORB)pRequest)->ErrorCode;
  635.  
  636.    pTraceBuffer->BlocksXferred = ((NPIORB_EXECUTEIO)pRequest)->BlocksXferred;
  637.  
  638.    if (TraceFlags & TF_RAS)
  639.       DevHelp_RAS(RAS_MAJOR_DISK, RAS_MINOR_IORB | 0x0080,           /*@V64478*/
  640.                                      sizeof(TCBD), (PBYTE) pTraceBuffer);
  641.    else if (TraceFlags & TF_DEKKO)
  642.       DekkoTrace(RAS_MINOR_IORB | 0x80, sizeof(TCBD), (PBYTE) pTraceBuffer);
  643.  
  644.    else if (TraceFlags & TF_PERFVIEW)
  645.       PerfViewTrace (TraceEvent, pRequest, pUnitCB);
  646. }
  647. /*------------------------------------------------------------------------
  648. ;
  649. ;** TraceIORBInternal  - Internal IORB Trace
  650. ;
  651. ;   VOID TraceIORBInternal (USHORT TraceEvent, PBYTE pRequest)
  652. ;
  653. ;   ENTRY:    TraceEvent       - Trace Flags
  654. ;             pRequest         - Request to trace
  655. ;
  656. ;   RETURN:   VOID
  657. ;
  658. ;   EFFECTS:
  659. ;
  660. ------------------------------------------------------------------------*/
  661. VOID TraceIORBInternal (TraceEvent, pRequest)
  662.  
  663. USHORT TraceEvent;
  664. PBYTE  pRequest;
  665.  
  666. {
  667.    NPITCB pTraceRec;
  668.    PBYTE  pPkt;
  669.  
  670.    if ( (DDFlags & DDF_INIT_TIME) || (pDMTraceBuf == 0) )
  671.       return;
  672.  
  673.    PUSHFLAGS;
  674.    DISABLE;
  675.  
  676.    pTraceRec = (NPITCB) pDMTraceHead;
  677.  
  678.    (NPIORB_DMWORK) pPkt = (NPIORB_DMWORK) &(((NPIORB)pRequest)->DMWorkSpace[0]);
  679.    pTraceRec->Unit = ((NPIORB_DMWORK)pPkt)->pUnitCB->PhysDriveNum;
  680.    pTraceRec->pIORB = OFFSETOF(pRequest);
  681.    pTraceRec->CommandModifier = (UCHAR) ((NPIORB)pRequest)->CommandModifier;
  682.    pTraceRec->CommandCode = (UCHAR) ((NPIORB)pRequest)->CommandCode;
  683.    pTraceRec->Status =  ((NPIORB)pRequest)->Status;
  684.    pTraceRec->ErrorCode = ((NPIORB)pRequest)->ErrorCode;
  685.  
  686.    if ( ((NPIORB)pRequest)->CommandCode == IOCC_EXECUTE_IO )
  687.    {
  688.       pTraceRec->rba = ((NPIORB_EXECUTEIO)pRequest)->RBA;
  689.       pTraceRec->BlockCount = ((NPIORB_EXECUTEIO)pRequest)->BlockCount;
  690.    }
  691.    else
  692.    {
  693.       pTraceRec->rba = 0;
  694.       pTraceRec->BlockCount = 0;
  695.    }
  696.  
  697.    pTraceRec->Event = RAS_MINOR_IORB;
  698.    if (TraceEvent & TRACE_ASYNCDONE)
  699.       pTraceRec->Event |= 0x80;
  700.  
  701.    pDMTraceHead += sizeof(ITCB);
  702.  
  703.    if (pDMTraceHead >= pDMTraceEnd)
  704.       pDMTraceHead = pDMTraceBuf;
  705.  
  706.    POPFLAGS;
  707. }
  708.  
  709.  
  710. /*------------------------------------------------------------------------
  711. ;
  712. ;** GetCmdString - Get command code string
  713. ;
  714. ;   USHORT GetCmdString (USHORT TraceEvent)
  715. ;
  716. ;   ENTRY:    TraceEvent      - TraceFlags
  717. ;
  718. ;   RETURN:   USHORT          - Two char ASCII command code
  719. ;
  720. ;   EFFECTS:
  721. ;
  722. ------------------------------------------------------------------------*/
  723. USHORT GetCmdString (TraceEvent)
  724.  
  725. USHORT TraceEvent;
  726.  
  727. {
  728.    USHORT Cmd;
  729.  
  730.    UCHAR  Char1 = ' ';
  731.    UCHAR  Char2 = ' ';
  732.  
  733.    if (TraceEvent & TRACE_READ)
  734.        Char1 = 'R';
  735.    if (TraceEvent & TRACE_WRITE)
  736.        Char1 = 'W';
  737.    if (TraceEvent & TRACE_FORMAT)
  738.        Char1 = 'F';
  739.  
  740.    if (TraceEvent & TRACE_VERIFY)
  741.        Char2 = 'V';
  742.    else if (TraceEvent & TRACE_PREFETCH)
  743.        Char2 = 'P';
  744.  
  745.    Cmd = Char1 + Char2 * 256;
  746.  
  747.    return(Cmd);
  748.  
  749. }
  750.  
  751. /*------------------------------------------------------------------------
  752. ;
  753. ;** GetTraceType - Get Trace Type
  754. ;
  755. ;   USHORT GetTraceType (USHORT TraceEvent, pRequest)
  756. ;
  757. ;   ENTRY:    TraceEvent      - Trace Flags
  758. ;             pRequest        - Request
  759. ;
  760. ;   RETURN:   USHORT          - Trace Flags
  761. ;
  762. ;   EFFECTS:
  763. ;
  764. ------------------------------------------------------------------------*/
  765. USHORT GetTraceType (TraceEvent, pRequest)
  766.  
  767. USHORT TraceEvent;
  768. PBYTE  pRequest;
  769.  
  770. {
  771.    USHORT Cmd, i;
  772.  
  773.    if (TraceEvent & TRACE_STRAT1)
  774.    {
  775.       Cmd = (USHORT) ((PRPH)pRequest)->Cmd;
  776.       if (Cmd == CMDGenIOCTL)
  777.           Cmd = (USHORT) ((Cmd << 8) + ((PRP_GENIOCTL)pRequest)->Function);
  778.    }
  779.    else if (TraceEvent & TRACE_STRAT2)
  780.       Cmd=(USHORT)((PB_REQ_LIST*256)+((PPB_Read_Write)pRequest)->RqHdr.Command_Code);
  781.    else if (TraceEvent & TRACE_IORB)
  782.       Cmd = ((((PIORB)pRequest)->CommandCode) << 8) +
  783.              ((PIORB)pRequest)->CommandModifier;
  784.  
  785.    for (i = 0; i < sizeof(CmdTable)/sizeof(CMDTABLE); i++)           /*@V84908*/
  786.       if (CmdTable[i].Cmd == Cmd)
  787.          return(CmdTable[i].CmdType);
  788.  
  789.  
  790.   return(0);
  791. }
  792.  
  793.  
  794.  
  795.  
  796.  
  797. /*------------------------------------------------------------------------
  798. ;
  799. ;** DekkoTrace - Perform Dekko tracing
  800. ;
  801. ;   VOID DekkoTrace (USHORT MinorCode, USHORT TraceSize, PBYTE pTraceBuffer)
  802. ;
  803. ;   ENTRY:    MinorCode        - Minor Code
  804. ;             TraceSize        - Size of data to trace
  805. ;             pTraceBuffer     - Pointer to trace buffer
  806. ;
  807. ;   RETURN:   VOID
  808. ;
  809. ;   EFFECTS:
  810. ;
  811. ------------------------------------------------------------------------*/
  812. VOID DekkoTrace (MinorCode, TraceSize, pTraceBuffer)
  813.  
  814. USHORT MinorCode;
  815. USHORT TraceSize;
  816. PBYTE  pTraceBuffer;
  817.  
  818. {
  819.    struct Dekko_Addr FAR *pDekko;
  820.    USHORT i;
  821.    PUSHORT pusTraceBuffer = (PUSHORT) pTraceBuffer;
  822.  
  823.    SELECTOROF(pDekko) = ((PInfoSegGDT)pSysInfoSeg)->SIS_MMIOBase;
  824.    OFFSETOF(pDekko) = 0;
  825.  
  826.    pDekko->majmin_code = DEKKO_MAJOR_DISK * 256 + MinorCode;
  827.  
  828.    for (i = 0; i < TraceSize/2; i++)
  829.    {
  830.       pDekko->perf_data = (USHORT) *(pusTraceBuffer+i);
  831.    }
  832. }
  833.  
  834.  
  835. #define ADJUST_STACK_POINTER
  836.  
  837. /*------------------------------------------------------------------------
  838. ;
  839. ;** PerfViewTrace - Perform perfview tracing
  840. ;
  841. ;   VOID PerfViewTrace (USHORT TraceEvent,  PBYTE pRequest, NPUNITCB pUnitCB)
  842. ;
  843. ;   ENTRY:    TraceEvent       - Trace Flags
  844. ;             pRequest         - Pointer to request
  845. ;             pUnitCB          - Pointer to UnitCB
  846. ;
  847. ;   RETURN:   VOID
  848. ;
  849. ;   EFFECTS:
  850. ;
  851. ------------------------------------------------------------------------*/
  852. VOID PerfViewTrace (TraceEvent, pRequest, pUnitCB)
  853.  
  854. USHORT   TraceEvent;
  855. PBYTE    pRequest;
  856. NPUNITCB pUnitCB;
  857.  
  858. {
  859.    USHORT i, Count, TraceType;
  860.    NPIORB_DMWORK pDMWork;                                            /*@V55646*/
  861. /* The pPerfViewDB variable (good only to shorten construes) was replaced */ /*@V53225*/
  862. /* by an equivalent "defined" PVWDB.  This makes for more efficient code. */ /*@V53225*/
  863.  
  864. #define PVWDB  (pUnitCB->PerfViewDB)                                 /*@V53225*/
  865.  
  866. /* The following function definitions StartTimer and StopTimer    */ /*@V53225*/
  867. /* were added to circumvent the problem caused by the header file */ /*@V53225*/
  868. /* preprocessor (h2inc.exe) which does not parse properly PFN     */ /*@V53225*/
  869. /* definitions and treats PASCAL calls as CDEL calls.             */ /*@V53225*/
  870.  
  871.    VOID (FAR PASCAL *StartTimer) (PTIMR);                            /*@V53225*/
  872.    VOID (FAR PASCAL *StopTimer) (PTIMR);                             /*@V53225*/
  873.  
  874.  
  875.  
  876.    pDMWork = (NPIORB_DMWORK) &((NPIORB_EXECUTEIO)pRequest)->iorbh.DMWorkSpace; /*@V55646*/
  877.  
  878.    if ( (PVWDB.pfdbh.dbh_pfnTmrSub == 0) ||                          /*@V53225*/
  879.       (PVWDB.pfdbh.dbh_pfnTmrAdd == 0) ||                            /*@V53225*/
  880.       (pUnitCB->UnitInfo.UnitFlags & UF_REMOVABLE) )                 /*@V53225*/
  881.        return;     /* return immediately */                          /*@V53225*/
  882.  
  883.    if (!(pDMWork->Flags & DMW_PERFVIEW_ACTIVE) &&                    /*@V55646*/
  884.       ((TraceEvent & TRACE_IORB) && (TraceEvent & TRACE_ASYNCDONE)) )/*@V55646*/
  885.        return;                                                       /*@V55646*/
  886.  
  887.    if (!(PFV_PreviousState & PFV_Active)) {                          /*@V55646*/
  888.       PFV_PreviousState |= PFV_Active;                               /*@V55646*/
  889.       Initialize_PFV();                                              /*@V55646*/
  890.    } /* endif */                                                     /*@V55646*/
  891.  
  892.    PVWDB.pfdbh.dbh_ulSem++;
  893.  
  894.    StartTimer = (PFN) (PVWDB.pfdbh.dbh_pfnTmrSub);                   /*@V53225*/
  895.    StopTimer  = (PFN) (PVWDB.pfdbh.dbh_pfnTmrAdd);                   /*@V53225*/
  896.  
  897.    PUSHFLAGS;                                                        /*@V56109*/
  898.    DISABLE;                                                          /*@V56109*/
  899.    if ( (TraceEvent & TRACE_IORB) && (TraceEvent & TRACE_ENTRY) )
  900.    {
  901.       pDMWork->Flags |= DMW_PERFVIEW_ACTIVE;                         /*@V55646*/
  902.       if (TraceEvent & TRACE_READ)
  903.       {
  904.  
  905.          PVWDB.NumReads++;
  906.          PVWDB.ReadBytes +=
  907.                            (ULONG)((NPIORB_EXECUTEIO)pRequest)->BlockCount;
  908.          PVWDB.Read.ql_ct++;                                         /*       */
  909.          /*  Start timer if counter is one */                        /*@V53225*/
  910.          if ((PVWDB.Read.ql_ct==1) &&
  911.             (PVWDB.Write.ql_ct==0))                                  /*@V53225*/
  912.              StartTimer ((PTIMR)&PVWDB.Busy);                        /*@V53225*/
  913.          StartTimer((PTIMR)&PVWDB.Read.ql_tm);                       /*       */
  914.       }
  915.       else if (TraceEvent & TRACE_WRITE)
  916.       {
  917.  
  918.  
  919.          PVWDB.NumWrites++;
  920.          PVWDB.WriteBytes +=
  921.                            (ULONG)((NPIORB_EXECUTEIO)pRequest)->BlockCount;
  922.          PVWDB.Write.ql_ct++;                                        /*       */
  923.          if ((PVWDB.Read.ql_ct==0) &&
  924.             (PVWDB.Write.ql_ct==1))                                  /*@V53225*/
  925.                StartTimer((PTIMR)&PVWDB.Busy);                       /*@V53225*/
  926.          StartTimer((PTIMR)&PVWDB.Write.ql_tm);                      /*       */
  927.       }
  928.    }
  929.    else if ( (TraceEvent & TRACE_IORB) && (TraceEvent & TRACE_ASYNCDONE))
  930.    {
  931.       if (TraceEvent & TRACE_READ) {
  932.          PVWDB.Read.ql_ct--;                                         /*       */
  933.  
  934.          if ((PVWDB.Read.ql_ct==0) &&
  935.             (PVWDB.Write.ql_ct==0))                                  /*@V53225*/
  936.              StopTimer((PTIMR)&PVWDB.Busy);                          /*@V53225*/
  937.  
  938.          StopTimer((PTIMR)&PVWDB.Read.ql_tm);                        /*       */
  939.       }                                                              /*       */
  940.       else
  941.       {
  942.         if (TraceEvent & TRACE_WRITE) {
  943.           PVWDB.Write.ql_ct--;                                       /*       */
  944.  
  945.          if ((PVWDB.Read.ql_ct==0) &&
  946.             (PVWDB.Write.ql_ct==0))                                  /*@V53225*/
  947.              StopTimer((PTIMR)&PVWDB.Busy);                          /*@V53225*/
  948.  
  949.           StopTimer((PTIMR)&PVWDB.Write.ql_tm);                      /*       */
  950.         }                                                            /*       */
  951.       }
  952.    }
  953.  
  954.    ENABLE;                                                           /*@V56109*/
  955.    POPFLAGS;                                                         /*@V56109*/
  956.    PVWDB.pfdbh.dbh_ulSem--;
  957. }
  958.  
  959. VOID Initialize_PFV()                                                /*@V55646*/
  960. {
  961.   NPUNITCB pUnitCB;
  962.  
  963.   for( pUnitCB=pVolCB_80->pUnitCB; pUnitCB; pUnitCB = pUnitCB->pNextUnitCB) {
  964.      pUnitCB->PerfViewDB.Read.ql_ct          = 0;
  965.      pUnitCB->PerfViewDB.Read.ql_tm.qw_ulLo  = 0;
  966.      pUnitCB->PerfViewDB.Read.ql_tm.qw_ulHi  = 0;
  967.  
  968.      pUnitCB->PerfViewDB.Write.ql_ct         = 0;
  969.      pUnitCB->PerfViewDB.Write.ql_tm.qw_ulLo = 0;
  970.      pUnitCB->PerfViewDB.Write.ql_tm.qw_ulHi = 0;
  971.  
  972.      pUnitCB->PerfViewDB.Busy.qw_ulLo        = 0;
  973.      pUnitCB->PerfViewDB.Busy.qw_ulHi        = 0;
  974.   }
  975. }
  976.  
  977.