home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / SAMPL.ZIP / SPMSAMPL.C next >
Text File  |  1993-02-03  |  14KB  |  422 lines
  1. /**************************SPMSAMPL.C*****************************************/
  2.  
  3.  
  4. #define  INCL_NOPM
  5. #define  INCL_DOS
  6. #define  INCL_DOSERRORS
  7. #include <os2.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <math.h>
  12. #include "spmapi.h"
  13. #include "spmctrgp.h"
  14.  
  15. #define INIT_LOG    TRUE    /* activate logging */
  16. #define MAXDISKS    26
  17.  
  18. typedef struct _RETURN_AREA
  19. {
  20.    QUERYHDR    quHdr;
  21.    CHAR        returnstr[10000];
  22. }  RETURN_AREA;
  23.  
  24. VOID do_return (USHORT, PEXTENDEDRC, PVOID, USHORT, USHORT);
  25. VOID do_data (PVOID, USHORT, USHORT);
  26.  
  27.  
  28. #define MAX_TRIES          5    /* arbitrary */
  29.  
  30. VOID main (argc, argv)
  31. INT  argc;
  32. CHAR *argv[];
  33. {
  34.  
  35.  
  36. USHORT            rc;
  37. CHAR              tmpstr[256];
  38. CHAR              szLogFileName[256], szQFileName[256], szIlogName[256];
  39. USHORT            n, counter;
  40. BOOL              TERM_LOG, CLOSE_LOG;
  41. FILTERSPEC        fsFilters;
  42. RETURN_AREA       return1, return2;
  43. USHORT            usLogRecLen;
  44. PVOID             pbLogRec;
  45. QUILOGSTAT        *pquilogstat;
  46. LOGFILEHANDLE     LogHandle;
  47. EXTENDEDRC        *pxrcRC, xrcRC;
  48. USHORT            hFileHandle;
  49. USHORT            AAction, ABytesWritten;
  50. LONG              lNewFilePtr;
  51.  
  52.     n = 0;
  53.     strcpy(tmpstr, "c:\\apilog.txt");
  54.     while ((rc = DosOpen(tmpstr,&hFileHandle,&AAction,(ULONG) 0,
  55.         (USHORT) 0x0000,(USHORT) 0x11,(USHORT) 0x0042,(ULONG) 0))
  56.         && (++n < MAX_TRIES));
  57.     if (rc)
  58.     {
  59.         printf ("\nc:\\apilog.txt was not created or failed to open\n");
  60.         exit (1);
  61.     }
  62.     else
  63.     {
  64.         if (AAction == (USHORT)1)
  65.             DosChgFilePtr(hFileHandle, 0L, 2, &lNewFilePtr);
  66.         strcpy(tmpstr, "\n\0");
  67.         DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  68.     }
  69.  
  70.     /* initialize logfilename */
  71.     strcpy ( szLogFileName,"aLogFile.log");
  72.  
  73.     /* initialize start and end times for logging and data get */
  74.     /* realtime = 0e0 */
  75.     if (INIT_LOG) tmpstr[0] = '\0';
  76.     else strcpy(tmpstr,"01/06/1993:00:00:00");
  77.  
  78.     fsFilters.dtStartDateTime = '\0';
  79.     if ((fsFilters.dtStartDateTime = str2dt(tmpstr)) == DTERROR)
  80.     {
  81.         if (tmpstr[0])
  82.         {
  83.            strcpy (tmpstr, "invalid Start parameter entered\n");
  84.            DosWrite(hFileHandle, tmpstr, strlen(tmpstr), &ABytesWritten);
  85.            exit(1);
  86.         }
  87.         else fsFilters.dtStartDateTime = '\0';
  88.     }
  89.  
  90.     if (INIT_LOG) tmpstr[0] = '\0';
  91.     else strcpy(tmpstr,"01/06/1993:09:15:00");
  92.     fsFilters.dtEndDateTime = '\0';
  93.     if ((fsFilters.dtEndDateTime = str2dt(tmpstr)) == DTERROR)
  94.     {
  95.         if (tmpstr[0])
  96.         {
  97.            strcpy (tmpstr, "invalid End parameter entered\n");
  98.            DosWrite(hFileHandle, tmpstr, strlen(tmpstr), &ABytesWritten);
  99.            exit(1);
  100.         }
  101.         else fsFilters.dtEndDateTime = '\0';
  102.     }
  103.  
  104.  
  105.     /* initialize space for record data to be returned to */
  106.     usLogRecLen = SPM_TYPE10_MAX_SIZE;
  107.     pbLogRec = (PVOID) malloc (usLogRecLen);
  108.  
  109.  
  110.     if (INIT_LOG)
  111.     {
  112.         rc = SPMAPIInit((PSZ SPMPTR) &szLogFileName, -1,(PEXTENDEDRC) &xrcRC);
  113.         if ((!rc) || (xrcRC.FunctionRC == SPMAPI_ERR_OBJECTINUSE))
  114.         {
  115.             if(xrcRC.FunctionRC == SPMAPI_ERR_OBJECTINUSE) TERM_LOG = FALSE;
  116.             else TERM_LOG = TRUE;
  117.             DosSleep(1000);
  118.             n = 0;
  119.             return1.quHdr.usResultMax = sizeof(return1);
  120.             return1.quHdr.pbResult = return1.returnstr;
  121.             while((n++ < MAX_TRIES) &&
  122.                 (rc = SPMAPIQuery((QUOPTION) SPM_QU_ILOG_LIST,
  123.                 (PSZ SPMPTR) &szLogFileName,(PVOID SPMPTR) &return1,
  124.                 (PEXTENDEDRC) &xrcRC)));
  125.             if(!rc)
  126.             {
  127.                 return2.quHdr.usResultMax = sizeof(return2);
  128.                 pquilogstat = (QUILOGSTAT *)return2.returnstr;
  129.                 szIlogName[0] = '\0';
  130.                 /* get path to logfile */
  131.                 rc = SPMAPIQualifyFileName ((PSZ SPMPTR) &szLogFileName,
  132.                     (USHORT)256, (PSZ SPMPTR) &szQFileName,
  133.                     (PEXTENDEDRC) &xrcRC);
  134.             }
  135.             n = 0;
  136.             /* wait for logfile to activate */
  137.             while ((return1.returnstr[n] != '\0') && (szIlogName[0] == '\0'))
  138.             {
  139.                 counter = 0;
  140.                 while (return1.returnstr[n] != '\0')
  141.                 szIlogName[counter++] = return1.returnstr[n++];
  142.                 szIlogName[counter] = '\0';
  143.                 n++;
  144.                 if ((rc = SPMAPIQuery((QUOPTION) SPM_QU_ILOG_STAT,
  145.                     (PSZ SPMPTR) &szIlogName,(PVOID SPMPTR) &return2,
  146.                     (PEXTENDEDRC) &xrcRC)) ||
  147.                     (strcmp(pquilogstat->szLogFileName,
  148.                     szQFileName))) szIlogName[0] = '\0';
  149.             }
  150.         }
  151.     }
  152.  
  153.     /* open logfile */
  154.     rc = SPMAPIOpen((PSZ SPMPTR) &szLogFileName,
  155.         (PFILTERSPEC) &fsFilters, (PLOGFILEHANDLE) &LogHandle,
  156.         (PEXTENDEDRC) &xrcRC);
  157.     /* error process here */
  158.  
  159.     /* get data from logfile */
  160.     while((n++ < MAX_TRIES) &&
  161.         (rc = SPMAPIGetData((PLOGFILEHANDLE) &LogHandle,
  162.         (PVOID SPMPTR) pbLogRec, (USHORT) usLogRecLen,
  163.         (PUSHORT SPMPTR) &usLogRecLen, (PVOID) NULL, (PVOID) NULL,
  164.         (PEXTENDEDRC) pxrcRC)));
  165.     do_return(rc, &xrcRC, pbLogRec, (USHORT)SPM_TYPE10_MAX_SIZE,
  166.         hFileHandle);
  167.  
  168.    if (CLOSE_LOG)
  169.    {
  170.       rc = SPMAPIClose((PLOGFILEHANDLE) &LogHandle, (PEXTENDEDRC) &xrcRC);
  171.    }
  172.  
  173.    if (TERM_LOG)
  174.    {
  175.       rc = SPMAPITerm((PSZ SPMPTR) &szLogFileName, (USHORT) SPMAPI_HALT,
  176.          (PEXTENDEDRC) &xrcRC);
  177.  
  178.    }
  179.  
  180.    exit (0);
  181.  
  182. }
  183.  
  184. VOID do_return (USHORT rc, PEXTENDEDRC xrcRC, PVOID r_ptr, USHORT len,
  185.    USHORT hFileHandle)
  186. {
  187. CHAR              tmpstr[256], numstr[80];
  188. USHORT            ABytesWritten;
  189.  
  190.  
  191.     /* process returns here */
  192.     if(rc)
  193.     {
  194.         itoa (rc, numstr, 10);
  195.         strncpy(tmpstr, "\nrc = \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 23);
  196.         strcat (tmpstr, numstr);
  197.         DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  198.  
  199.         if (xrcRC != NULL)
  200.         {
  201.             itoa (xrcRC->FunctionCode, numstr, 10);
  202.             strncpy(tmpstr, "\nFunctionCode = \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
  203.                 32);
  204.             strcat (tmpstr, numstr);
  205.             itoa (xrcRC->FunctionRC, numstr, 10);
  206.             strncat(tmpstr, "; FunctionRC = \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 30);
  207.             strcat (tmpstr, numstr);
  208.             DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  209.         }
  210.     }
  211.     else if (r_ptr != NULL) do_data(r_ptr, len, hFileHandle);
  212.     return;
  213. }
  214.  
  215. VOID do_data (PVOID r_ptr, USHORT len, USHORT hFileHandle)
  216. {
  217. USHORT          ABytesWritten;
  218. CHAR            tmpstr[256], numstr[80];
  219. SHORT           n, count, offset, grpcnt;
  220. PBYTE           pTop, pByte, pbBuf;
  221. MEM             *pMem;
  222. WKS             *pWKS;
  223. CPU             *pCPU;
  224. DSK             *pDSK;
  225. ULONG           ulMemGroupTotalRAMPages;
  226. ULONG           ulTotalRAMPages;
  227. SHORT           sMemPerCent;
  228. USHORT          usSwapIn, usSwapOut;
  229. USHORT          usNotIdlePerCent;
  230. USHORT          usGroupOrdinal;
  231. USHORT          usTemp;
  232. FPDATETIME      dtActualSamplePeriod, dtGetDataTimeStamp;
  233. BOOL            fHaveValidTotalRAM;
  234. SHORT           sWorkingSet;
  235. USHORT          usWorkingPages;
  236. SHORT           sFixMemPerCent;
  237. DATARECHDR      *pHdr;
  238. DCFGROUP        *pGRP;
  239.  
  240.    offset = 0;
  241.  
  242.    // Print HEADER
  243.    n = 0;
  244.    while(n < 256) tmpstr[n++] ='\0';
  245.    pHdr = (DATARECHDR *) r_ptr;
  246.    strcpy (tmpstr, "\nBasic Header:");
  247.    DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  248.  
  249.    n = 0;
  250.    while(n < 256) tmpstr[n++] ='\0';
  251.  
  252.    strcpy (tmpstr, "\n  usLL: ");
  253.    itoa ((SHORT)(pHdr->bhDR.usLL), numstr, 10);
  254.    strcat(tmpstr, numstr);
  255.    DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  256.  
  257.    n = 0;
  258.    while(n < 256) tmpstr[n++] ='\0';
  259.  
  260.    strcpy (tmpstr, "\n  ucRecordSeries: ");
  261.    ltoa ((LONG)(pHdr->bhDR.ucRecordSeries), numstr, 10);
  262.    strcat(tmpstr,numstr);
  263.    DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  264.  
  265.    n = 0;
  266.    while(n < 256) tmpstr[n++] ='\0';
  267.  
  268.    strcpy (tmpstr, "\n  ucRecordSubType: ");
  269.    ltoa ((LONG)(pHdr->bhDR.ucRecordSubType), numstr, 10);
  270.    strcat(tmpstr,numstr);
  271.    DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  272.  
  273.    n = 0;
  274.    while(n < 256) tmpstr[n++] ='\0';
  275.    strcpy (tmpstr, "\n  ucRecordType: ");
  276.    ltoa ((LONG)(pHdr->bhDR.ucRecordType), numstr, 10);
  277.    strcat(tmpstr,numstr);
  278.    DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  279.  
  280.    //Print nodename
  281.    while(n < 256) tmpstr[n++] ='\0';
  282.    strcpy (tmpstr, "\nszNodeName: ");
  283.    strcat(tmpstr, pHdr->szNodeName);
  284.    DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  285.  
  286.    //Print Group Count
  287.    n = 0;
  288.    while(n < 256) tmpstr[n++] ='\0';
  289.    strcpy (tmpstr, "\nusGrpCnt: ");
  290.    grpcnt = (SHORT)(*(&(pHdr->usGrpCnt) + offset));
  291.    itoa (grpcnt, numstr, 10);
  292.    strcat(tmpstr, numstr);
  293.    DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  294.  
  295.    //Print each DCFGROUP and data
  296.    if (grpcnt != 0)
  297.    {
  298.       n = 0;
  299.       while(n < 256) tmpstr[n++] ='\0';
  300.       strcpy (tmpstr, "\nDCFGROUP: ");
  301.       DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  302.       pByte = (PBYTE)r_ptr + sizeof(DATARECHDR) + 2*offset;
  303.       dtActualSamplePeriod =((DATARECHDR*)pByte)->dtMedEnd - ((DATARECHDR*)pByte)->dtMedStart;
  304.       dtGetDataTimeStamp = ((DATARECHDR*)pByte)->dtMedEnd;
  305.  
  306.       pTop = pByte;
  307.    }
  308.  
  309.    for (count = 0; count < grpcnt; count++)
  310.    {
  311.       pGRP = (DCFGROUP *) pByte;
  312.  
  313.       //Print length
  314.       n = 0;
  315.       while(n < 256) tmpstr[n++] ='\0';
  316.       strcpy (tmpstr, "\n  usLL: ");
  317.       itoa ((SHORT)pGRP->usLL, numstr, 10);
  318.       strcat(tmpstr, numstr);
  319.       DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  320.  
  321.       //Print ordinal
  322.       n = 0;
  323.       while(n < 256) tmpstr[n++] ='\0';
  324.       strcpy (tmpstr, "\n  usSPMGrp: ");
  325.       itoa (pGRP->usSPMGrp, numstr, 10);
  326.       strcat(tmpstr, numstr);
  327.       DosWrite(hFileHandle, tmpstr, strlen(tmpstr),&ABytesWritten);
  328.  
  329.       //Get data
  330.  
  331.  
  332.     switch (pGRP->usSPMGrp)
  333.     {
  334.         case SPMOrdinal_MEM:
  335.               pbBuf = (PBYTE) &(pGRP->byDataStart);
  336.               pMem = (MEM *)pbBuf;
  337.  
  338.               /***************************************************************/
  339.               /*          Calculate total pages for the MEM group            */
  340.               /***************************************************************/
  341.               ulMemGroupTotalRAMPages =
  342.                  (ULONG)( pMem->qlQUsed.ct + pMem->qlQFree.ct );
  343.  
  344.               /***************************************************************/
  345.               /*                   Calculate % used memory                   */
  346.               /***************************************************************/
  347.               if ( ulMemGroupTotalRAMPages > 0L )
  348.                  sMemPerCent = (SHORT) ((ULONG)(pMem->qlQUsed.ct) * 100L /
  349.                      ulMemGroupTotalRAMPages );
  350.               else sMemPerCent = 0;
  351.  
  352.              /***************************************************************/
  353.              /*                   Calculate paging                          */
  354.              /***************************************************************/
  355.              usSwapIn  = (USHORT)(pMem->ctSwapIn  * 10 / dtActualSamplePeriod );
  356.              usSwapOut = (USHORT)(pMem->ctSwapOut * 10 / dtActualSamplePeriod );
  357.              break;
  358.  
  359.         case SPMOrdinal_WKS:
  360.             pbBuf = (PBYTE) &(pGRP->byDataStart);
  361.             pWKS  = (WKS *)pbBuf;
  362.  
  363.             /***************************************************************/
  364.             /*               Calculate working pages                       */
  365.             /***************************************************************/
  366.             usWorkingPages = (USHORT)(pWKS->qlQWorking.ct);
  367.  
  368.             /***************************************************************/
  369.             /*                      Display total RAM                      */
  370.             /***************************************************************/
  371.             ulTotalRAMPages = (ULONG)( pWKS->ctMemSize );
  372.             fHaveValidTotalRAM = TRUE;
  373.  
  374.             /***************************************************************/
  375.             /*                    Calculate working set                    */
  376.             /***************************************************************/
  377.             if ( fHaveValidTotalRAM )
  378.                 sWorkingSet = (SHORT) ((ULONG)usWorkingPages * 100L /
  379.                     ( ulTotalRAMPages ));
  380.             else sWorkingSet = 0;
  381.  
  382.             /***************************************************************/
  383.             /*                    Calculate % fixed memory                 */
  384.             /***************************************************************/
  385.             if ( fHaveValidTotalRAM )
  386.                 sFixMemPerCent = (SHORT) ((ULONG)pWKS->qlQResident.ct * 100L /
  387.                     ( ulTotalRAMPages ));
  388.             else sFixMemPerCent = 0;
  389.             break;
  390.  
  391.         case SPMOrdinal_CPU:
  392.             pbBuf = (PBYTE) &(pGRP->byDataStart);
  393.             pCPU  = (CPU *)pbBuf;
  394.  
  395.             usNotIdlePerCent = (USHORT)( pCPU->tvNotIdle * 100.0 /
  396.                 dtActualSamplePeriod ) ;
  397.             break;
  398.  
  399.         default:
  400.             // DISK
  401.             if (( usGroupOrdinal >= SPMOrdinal_DSK ) &&
  402.                 ( usGroupOrdinal <= (USHORT)( SPMOrdinal_DSK + MAXDISKS - 1 )))
  403.             {
  404.                 pbBuf = (PBYTE)&(pGRP->byDataStart);
  405.                 pDSK  = (DSK *)pbBuf;
  406.                 if (( pDSK->tvBusy >= (timer)0.0 ) &&
  407.                     ( pDSK->tvBusy <= (timer)dtActualSamplePeriod ))
  408.                 {
  409.                     usTemp = (USHORT)(( pDSK->tvBusy ) * 100L /
  410.                                  dtActualSamplePeriod ) ;
  411.                 }
  412.             }
  413.             break;
  414.  
  415.         } // end switch
  416.  
  417.         pTop += pGRP->usLL;
  418.         pByte = pTop;
  419.     }
  420.     return;
  421. }
  422.