windows-xp/Source/XPSP1/NT/base/tools/pperf/dll/p5ctrs.c

/*++ BUILD Version: 0001    // Increment this if a change has global effects

Copyright (c) 1992  Microsoft Corporation

Module Name:

    p5ctrs.c

Abstract:

    This file implements the Extensible Objects for  the P5 object type

Created:

    Russ Blake  24 Feb 93

Revision History


--*/

//
//  Include Files
//

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <string.h>
#include <winperf.h>
#include "p5ctrmsg.h" // error message definition
#include "p5ctrnam.h"
#include "p5msg.h"
#include "perfutil.h"
#include "pentdata.h"
#include "..\pstat.h"

//
//  References to constants which initialize the Object type definitions
//

extern P5_DATA_DEFINITION P5DataDefinition;


//
// P5 data structures
//

DWORD   dwOpenCount = 0;        // count of "Open" threads
BOOL    bInitOK = FALSE;        // true = DLL initialized OK
BOOL    bP6notP5 = FALSE;        // true for P6 processors, false for P5 CPUs

HANDLE  DriverHandle;           // handle of opened device driver

UCHAR   NumberOfProcessors;

#define     INFSIZE     60000
ULONG       Buffer[INFSIZE/4];


//
//  Function Prototypes
//
//      these are used to insure that the data collection functions
//      accessed by Perflib will have the correct calling format.
//

PM_OPEN_PROC    OpenP5PerformanceData;
PM_COLLECT_PROC CollectP5PerformanceData;
PM_CLOSE_PROC   CloseP5PerformanceData;

static
ULONG
InitPerfInfo()
/*++

Routine Description:

    Initialize data for perf measurements

Arguments:

   None

Return Value:

    Number of system processors (0 if error)

Revision History:

      10-21-91      Initial code

--*/

{
    UNICODE_STRING              DriverName;
    NTSTATUS                    status;
    OBJECT_ATTRIBUTES           ObjA;
    IO_STATUS_BLOCK             IOSB;
    SYSTEM_BASIC_INFORMATION                    BasicInfo;
    PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION   PPerfInfo;
    SYSTEM_PROCESSOR_INFORMATION CpuInfo;
    int                                         i;

    //
    //  Init Nt performance interface
    //

    NtQuerySystemInformation(
       SystemBasicInformation,
       &BasicInfo,
       sizeof(BasicInfo),
       NULL
    );

    NumberOfProcessors = BasicInfo.NumberOfProcessors;

    if (NumberOfProcessors > MAX_PROCESSORS) {
        return(0);
    }


    //
    // Open PStat driver
    //

    RtlInitUnicodeString(&DriverName, L"\\Device\\PStat");
    InitializeObjectAttributes(
            &ObjA,
            &DriverName,
            OBJ_CASE_INSENSITIVE,
            0,
            0 );

    status = NtOpenFile (
            &DriverHandle,                      // return handle
            SYNCHRONIZE | FILE_READ_DATA,       // desired access
            &ObjA,                              // Object
            &IOSB,                              // io status block
            FILE_SHARE_READ | FILE_SHARE_WRITE, // share access
            FILE_SYNCHRONOUS_IO_ALERT           // open options
            );

    if (!NT_SUCCESS(status)) {
        return 0;
    }

    NtQuerySystemInformation (
        SystemProcessorInformation,
        &CpuInfo,
        sizeof(CpuInfo),
        NULL);

    if ((CpuInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) &&
        (CpuInfo.ProcessorLevel == 6)) {
        // then this is a P6 so set the global flag
        bP6notP5 = TRUE;
    }

    return(NumberOfProcessors);
}

static
long
GetPerfRegistryInitialization
(
    HKEY     *phKeyDriverPerf,
    DWORD    *pdwFirstCounter,
    DWORD    *pdwFirstHelp
)
{
    long     status;
    DWORD    size;
    DWORD    type;

    // get counter and help index base values from registry
    //      Open key to registry entry
    //      read First Counter and First Help values
    //      update static data strucutures by adding base to
    //          offset value in structure.

    status = RegOpenKeyEx (
        HKEY_LOCAL_MACHINE,
        "SYSTEM\\CurrentControlSet\\Services\\PStat\\Performance",
        0L,
        KEY_ALL_ACCESS,
        phKeyDriverPerf);

    if (status != ERROR_SUCCESS) {
        REPORT_ERROR_DATA (P5PERF_UNABLE_OPEN_DRIVER_KEY, LOG_USER,
            &status, sizeof(status));
        // this is fatal, if we can't get the base values of the
        // counter or help names, then the names won't be available
        // to the requesting application  so there's not much
        // point in continuing.
        return(status);
    }

    size = sizeof (DWORD);
    status = RegQueryValueEx(
                *phKeyDriverPerf,
                "First Counter",
                0L,
                &type,
                (LPBYTE)pdwFirstCounter,
                &size);

    if (status != ERROR_SUCCESS) {
        REPORT_ERROR_DATA (P5PERF_UNABLE_READ_FIRST_COUNTER, LOG_USER,
            &status, sizeof(status));
        // this is fatal, if we can't get the base values of the
        // counter or help names, then the names won't be available
        // to the requesting application  so there's not much
        // point in continuing.
        return(status);
    }
    size = sizeof (DWORD);
    status = RegQueryValueEx(
                *phKeyDriverPerf,
                "First Help",
                0L,
                &type,
                (LPBYTE)pdwFirstHelp,
                &size);

    if (status != ERROR_SUCCESS) {
        REPORT_ERROR_DATA (P5PERF_UNABLE_READ_FIRST_HELP, LOG_USER,
            &status, sizeof(status));
        // this is fatal, if we can't get the base values of the
        // counter or help names, then the names won't be available
        // to the requesting application  so there's not much
        // point in continuing.
    }
    return(status);
}

DWORD APIENTRY
OpenP5PerformanceData(
    LPWSTR lpDeviceNames
)

/*++

Routine Description:

    This routine will open the driver which gets performance data on the
    P5.  This routine also initializes the data structures used to
    pass data back to the registry

Arguments:

    Pointer to object ID of each device to be opened (P5)


Return Value:

    None.

--*/

{
    DWORD ctr;
    LONG status;
    HKEY hKeyDriverPerf;
    DWORD dwFirstCounter;
    DWORD dwFirstHelp;
    PPERF_COUNTER_DEFINITION pPerfCounterDef;
    P5_COUNTER_DATA p5Data;

    //
    //  Since WINLOGON is multi-threaded and will call this routine in
    //  order to service remote performance queries, this library
    //  must keep track of how many times it has been opened (i.e.
    //  how many threads have accessed it). The registry routines will
    //  limit access to the initialization routine to only one thread
    //  at a time so synchronization (i.e. reentrancy) should not be
    //  a problem
    //

    if (!dwOpenCount) {
        // open Eventlog interface

        hEventLog = MonOpenEventLog();

        // open device driver to retrieve performance values

        NumberOfProcessors = (UCHAR)InitPerfInfo();

        // log error if unsuccessful

        if (!NumberOfProcessors) {
            REPORT_ERROR (P5PERF_OPEN_FILE_ERROR, LOG_USER);
            // this is fatal, if we can't get data then there's no
            // point in continuing.
            status = GetLastError(); // return error
            goto OpenExitPoint;
        }

        status = GetPerfRegistryInitialization(&hKeyDriverPerf,
                                               &dwFirstCounter,
                                               &dwFirstHelp);
        if (status == ERROR_SUCCESS) {
            // initialize P5 data
            P5DataDefinition.P5PerfObject.ObjectNameTitleIndex +=
                dwFirstCounter;

            P5DataDefinition.P5PerfObject.ObjectHelpTitleIndex +=
                dwFirstHelp;

            pPerfCounterDef = &P5DataDefinition.Data_read;

            for (ctr=0;
                 ctr < P5DataDefinition.P5PerfObject.NumCounters;
                 ctr++, pPerfCounterDef++) {

                pPerfCounterDef->CounterNameTitleIndex += dwFirstCounter;
                pPerfCounterDef->CounterHelpTitleIndex += dwFirstHelp;
            }
            // initialize P6 data
            P6DataDefinition.P6PerfObject.ObjectNameTitleIndex +=
                dwFirstCounter;

            P6DataDefinition.P6PerfObject.ObjectHelpTitleIndex +=
                dwFirstHelp;

            pPerfCounterDef = &P6DataDefinition.StoreBufferBlocks;

            for (ctr=0;
                 ctr < P6DataDefinition.P6PerfObject.NumCounters;
                 ctr++, pPerfCounterDef++) {

                pPerfCounterDef->CounterNameTitleIndex += dwFirstCounter;
                pPerfCounterDef->CounterHelpTitleIndex += dwFirstHelp;
            }
            RegCloseKey (hKeyDriverPerf); // close key to registry

            bInitOK = TRUE; // ok to use this function
        }
    }

    dwOpenCount++;  // increment OPEN counter

    status = ERROR_SUCCESS; // for successful exit

OpenExitPoint:

    return status;
}

static
void 
UpdateInternalStats()
{
    IO_STATUS_BLOCK             IOSB;

    // clear the buffer first

    memset (Buffer, 0, sizeof(Buffer));

    // get the stat's from the driver
    NtDeviceIoControlFile(
        DriverHandle,
        (HANDLE) NULL,          // event
        (PIO_APC_ROUTINE) NULL,
        (PVOID) NULL,
        &IOSB,
        PSTAT_READ_STATS,
        Buffer,                  // input buffer
        INFSIZE,
        NULL,                    // output buffer
        0
    );

}

DWORD APIENTRY
CollectP5PerformanceData(
    IN      LPWSTR  lpValueName,
    IN OUT  LPVOID  *lppData,
    IN OUT  LPDWORD lpcbTotalBytes,
    IN OUT  LPDWORD lpNumObjectTypes
)
/*++

Routine Description:

    This routine will return the data for the P5 counters.

Arguments:

   IN       LPWSTR   lpValueName
         pointer to a wide character string passed by registry.

   IN OUT   LPVOID   *lppData
         IN: pointer to the address of the buffer to receive the completed
            PerfDataBlock and subordinate structures. This routine will
            append its data to the buffer starting at the point referenced
            by *lppData.
         OUT: points to the first byte after the data structure added by this
            routine. This routine updated the value at lppdata after appending
            its data.

   IN OUT   LPDWORD  lpcbTotalBytes
         IN: the address of the DWORD that tells the size in bytes of the
            buffer referenced by the lppData argument
         OUT: the number of bytes added by this routine is writted to the
            DWORD pointed to by this argument

   IN OUT   LPDWORD  NumObjectTypes
         IN: the address of the DWORD to receive the number of objects added
            by this routine
         OUT: the number of objects added by this routine is writted to the
            DWORD pointed to by this argument

Return Value:

      ERROR_MORE_DATA if buffer passed is too small to hold data
         any error conditions encountered are reported to the event log if
         event logging is enabled.

      ERROR_SUCCESS  if success or any other error. Errors, however are
         also reported to the event log.

--*/
{
    //  Variables for reformating the data

    DWORD    CurProc;
    DWORD    SpaceNeeded;
    DWORD    dwQueryType;
    pPSTATS  pPentStats;
    DWORD    cReg0;               // pperf Register 0
    DWORD    cReg1;               // pperf Register 1
    DWORD    dwDerivedIndex;
    PVOID    pCounterData;

    WCHAR               ProcessorNameBuffer[11];
    UNICODE_STRING      ProcessorName;
    PP5_DATA_DEFINITION pP5DataDefinition;
    PP5_COUNTER_DATA    pP5Data;

    PP6_DATA_DEFINITION pP6DataDefinition;
    PP6_COUNTER_DATA    pP6Data;

    PERF_INSTANCE_DEFINITION *pPerfInstanceDefinition;

    UpdateInternalStats();      // get stats as early as possible

    pPentStats = (pPSTATS)((LPBYTE)Buffer + sizeof(ULONG));

    //
    // before doing anything else, see if Open went OK
    //
    if (!bInitOK) {
        // unable to continue because open failed.
        *lpcbTotalBytes = (DWORD) 0;
        *lpNumObjectTypes = (DWORD) 0;
        return ERROR_SUCCESS; // yes, this is a successful exit
    }

    // see if this is a foreign (i.e. non-NT) computer data request
    //
    dwQueryType = GetQueryType(lpValueName);

    if ((dwQueryType == QUERY_FOREIGN) ||
        (dwQueryType == QUERY_COSTLY)) {
        // this routine does not service requests for data from
        // Non-NT computers nor is this a "costly" counter
        *lpcbTotalBytes = (DWORD) 0;
        *lpNumObjectTypes = (DWORD) 0;
        return ERROR_SUCCESS;
    }

    if (dwQueryType == QUERY_ITEMS){
        // both p5 & p6 counters use the same object id
        if ( !(IsNumberInUnicodeList(
                   P5DataDefinition.P5PerfObject.ObjectNameTitleIndex,
                   lpValueName))) {

            // request received for data object not provided by this routine
            *lpcbTotalBytes = (DWORD) 0;
            *lpNumObjectTypes = (DWORD) 0;
            return ERROR_SUCCESS;
        }
    }

    if (bP6notP5) {
        pP6DataDefinition = (P6_DATA_DEFINITION *) *lppData;

        SpaceNeeded = sizeof(P6_DATA_DEFINITION) +
                      NumberOfProcessors *
                      (sizeof(PERF_INSTANCE_DEFINITION) +
                       (MAX_INSTANCE_NAME+1) * sizeof(WCHAR) +
                       sizeof(P6_COUNTER_DATA));
    } else {
        pP5DataDefinition = (P5_DATA_DEFINITION *) *lppData;

        SpaceNeeded = sizeof(P5_DATA_DEFINITION) +
                      NumberOfProcessors *
                      (sizeof(PERF_INSTANCE_DEFINITION) +
                       (MAX_INSTANCE_NAME+1) * sizeof(WCHAR) +
                       sizeof(P5_COUNTER_DATA));
    }

    if (*lpcbTotalBytes < SpaceNeeded) {
        *lpcbTotalBytes = (DWORD) 0;
        *lpNumObjectTypes = (DWORD) 0;
        return ERROR_MORE_DATA;
    }

    // ******************************************************************
    // ****                                                          ****
    // **** If here, then the data request includes this performance ****
    // ****  object and there's enough room for the data so continue ****
    // ****                                                          ****
    // ******************************************************************

    //
    // Copy the (constant and initialized) Object Type and counter definitions
    //  to the caller's data buffer
    //
    if (bP6notP5) {
        memmove(pP6DataDefinition,
                &P6DataDefinition,
                sizeof(P6_DATA_DEFINITION));

        pP6DataDefinition->P6PerfObject.NumInstances = NumberOfProcessors;

        pPerfInstanceDefinition = (PERF_INSTANCE_DEFINITION *)
                          &pP6DataDefinition[1];
    } else {
        memmove(pP5DataDefinition,
                &P5DataDefinition,
                sizeof(P5_DATA_DEFINITION));

        pP5DataDefinition->P5PerfObject.NumInstances = NumberOfProcessors;

        pPerfInstanceDefinition = (PERF_INSTANCE_DEFINITION *)
                                  &pP5DataDefinition[1];
    }

    //
    //  Format and collect P5 data from the system for each processor
    //


    for (CurProc = 0;
         CurProc < NumberOfProcessors;
         CurProc++, pPentStats++) {

        // get the index of the two counters returned by the pentium
        // performance register interface device driver

        cReg0 = pPentStats->EventId[0];
        cReg1 = pPentStats->EventId[1];

        // build the processor intstance structure

        ProcessorName.Length = 0;
        ProcessorName.MaximumLength = 11;
        ProcessorName.Buffer = ProcessorNameBuffer;

        // convert processor instance to a string for use as the instance
        // name
        RtlIntegerToUnicodeString(CurProc, 10, &ProcessorName);

        // initialize the instance structure and return a pointer to the
        // base of the data block for this instance
        MonBuildInstanceDefinition(pPerfInstanceDefinition,
                                   &pCounterData,
                                   0,
                                   0,
                                   CurProc,
                                   &ProcessorName);
        if (bP6notP5) {
            // do P6 data
            pP6Data = (PP6_COUNTER_DATA)pCounterData;

            // define the length of the data
            pP6Data->CounterBlock.ByteLength = sizeof(P6_COUNTER_DATA);

            // clear area so unused counters are 0
        
            memset((PVOID) &pP6Data->llStoreBufferBlocks, // start with 1st data field
                   0,
                   sizeof(P6_COUNTER_DATA) - sizeof(PERF_COUNTER_BLOCK));

            // load the 64bit values in the appropriate counter fields
            // all other values will remain zeroed

            if ((cReg0 < P6IndexMax) &&
                (P6IndexToData[cReg0] != PENT_INDEX_NOT_USED)) {
                *(LONGLONG *)((LPBYTE)pP6Data + P6IndexToData[cReg0]) = 
                    (pPentStats->Counters[0] & 0x000000FFFFFFFFFF);
            }
            if ((cReg1 < P6IndexMax) &&
                (P6IndexToData[cReg1] != PENT_INDEX_NOT_USED)) {
                *(LONGLONG *)((LPBYTE)pP6Data + P6IndexToData[cReg1]) = 
                    (pPentStats->Counters[1] & 0x000000FFFFFFFFFF);

            }

            // set the instance pointer to the first byte after this instance's 
            // counter data
            pPerfInstanceDefinition = (PERF_INSTANCE_DEFINITION *)
                                       ((PBYTE) pP6Data +
                                        sizeof(P6_COUNTER_DATA));
        } else {
            // do P5 data
            pP5Data = (PP5_COUNTER_DATA)pCounterData;

            // define the length of the data
            pP5Data->CounterBlock.ByteLength = sizeof(P5_COUNTER_DATA);

            // clear area so unused counters are 0
        
            memset((PVOID) &pP5Data->llData_read, // start with 1st data field
                   0,
                   sizeof(P5_COUNTER_DATA) - sizeof(PERF_COUNTER_BLOCK));

            // load the 64bit values in the appropriate counter fields
            // all other values will remain zeroed

            if ((cReg0 < P5IndexMax) &&
                (P5IndexToData[cReg0] != PENT_INDEX_NOT_USED)) {
                // only the low order 40 bits are valid so mask off the
                // others to prevent spurious values
                *(LONGLONG *)((LPBYTE)pP5Data + P5IndexToData[cReg0]) = 
                    (pPentStats->Counters[0] & 0x000000FFFFFFFFFF);
            }
            if ((cReg1 < P5IndexMax) &&
                (P5IndexToData[cReg1] != PENT_INDEX_NOT_USED)) {
                // only the low order 40 bits are valid so mask off the
                // others to prevent spurious values
                *(LONGLONG *)((LPBYTE)pP5Data + P5IndexToData[cReg1]) = 
                    (pPentStats->Counters[1] & 0x000000FFFFFFFFFF);
            }

            // see if the selected counters are part of a derived counter and 
            // update if necessary

            if ((cReg0 < P5IndexMax) && (cReg1 < P5IndexMax) &&
                (dwDerivedp5Counters[cReg0] && dwDerivedp5Counters[cReg1])) {
                for (dwDerivedIndex = 0; 
                     dwDerivedIndex < dwP5DerivedCountersCount;
                     dwDerivedIndex++) {
                    if ((cReg0 == P5DerivedCounters[dwDerivedIndex].dwCR0Index) &&
                        (cReg1 == P5DerivedCounters[dwDerivedIndex].dwCR1Index)) {
                        *(DWORD *)((LPBYTE)pP5Data + 
                            P5DerivedCounters[dwDerivedIndex].dwCR0FieldOffset) =
                                (DWORD)(pPentStats->Counters[0] & 0x00000000FFFFFFFF);
                        *(DWORD *)((LPBYTE)pP5Data + 
                            P5DerivedCounters[dwDerivedIndex].dwCR1FieldOffset) =
                                (DWORD)(pPentStats->Counters[1] & 0x00000000FFFFFFFF);
                        break; // out of loop
                    }
                }
            }

            // set the instance pointer to the first byte after this instance's 
            // counter data
            pPerfInstanceDefinition = (PERF_INSTANCE_DEFINITION *)
                                       ((PBYTE) pP5Data +
                                        sizeof(P5_COUNTER_DATA));
        }
    }
    // update arguments for return


    // update the object's length in the object def structure
    if (bP6notP5) {
        *lpcbTotalBytes = (DWORD)((PBYTE)pPerfInstanceDefinition -
                (PBYTE)pP6DataDefinition);
        pP6DataDefinition->P6PerfObject.TotalByteLength = *lpcbTotalBytes;
    } else {
    // return the size of this object's data
        *lpcbTotalBytes = (DWORD)((PBYTE)pPerfInstanceDefinition -
                (PBYTE)pP5DataDefinition);
        pP5DataDefinition->P5PerfObject.TotalByteLength = *lpcbTotalBytes;
    }
    // return the pointer to the next available byte in the data block
    *lppData = (PBYTE) pPerfInstanceDefinition;

    // return the number of objects returned in this data block
    *lpNumObjectTypes = PENT_NUM_PERF_OBJECT_TYPES;

    // always return success, unless there was not enough room in the 
    // buffer passed in by the caller
    return ERROR_SUCCESS;
}

DWORD APIENTRY
CloseP5PerformanceData(
)

/*++

Routine Description:

    This routine closes the open handles to P5 device performance counters

Arguments:

    None.


Return Value:

    ERROR_SUCCESS

--*/

{
    if (!(--dwOpenCount)) { // when this is the last thread...

        CloseHandle(DriverHandle);

        MonCloseEventLog();
    }

    return ERROR_SUCCESS;

}