|
|
/**********************************************************************//** Microsoft Windows NT **//** Copyright(c) Microsoft Corp., 1993 **//**********************************************************************/
/*
infoperf.c
This file implements the Extensible Performance Objects for the common INFO counters
FILE HISTORY: KeithMo 07-Jun-1993 Created, based on RussBl's sample code. MuraliK 02-Jun-1995 Added Counters for Atq I/O requests SophiaC 16-Oct-1995 Info/Access Product Split MuraliK 16-Nov-1995 Removed undoc apis
*/
#include <windows.h>
#include <winperf.h>
#include <lm.h>
#include <inetinfo.h>
#include <string.h>
#include <stdlib.h>
#include <infoctrs.h>
#include <infodata.h>
#include <perfutil.h>
#include <iis64.h>
#include "infomsg.h"
# include "apiutil.h"
//
// Private constants.
//
#define APP_NAME (TEXT("IISInfoCtrs"))
//
// Private globals.
//
DWORD cOpens = 0; // Active "opens" reference count.
BOOL fInitOK = FALSE; // TRUE if DLL initialized OK.
HANDLE hEventLog = NULL; // event log handle
#if DBG
DWORD INFODebug = 0; // Debug behaviour flags.
#endif // DBG
//
// Public prototypes.
//
PM_OPEN_PROC OpenINFOPerformanceData;PM_COLLECT_PROC CollectINFOPerformanceData;PM_CLOSE_PROC CloseINFOPerformanceData;
//
// Public functions.
//
/*******************************************************************
NAME: OpenINFOPerformanceData
SYNOPSIS: Initializes the data structures used to communicate performance counters with the registry.
ENTRY: lpDeviceNames - Poitner to object ID of each device to be opened.
RETURNS: DWORD - Win32 status code.
HISTORY: KeithMo 07-Jun-1993 Created.
********************************************************************/DWORD OpenINFOPerformanceData( LPWSTR lpDeviceNames ){ DWORD err = NO_ERROR; HKEY hkey = NULL; DWORD size; DWORD type; DWORD dwFirstCounter; DWORD dwFirstHelp; PERF_COUNTER_DEFINITION * pctr; DWORD i;
//
// Since SCREG 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( !fInitOK ) {
//
// This is the *first* open.
//
// open the event log interface
if (hEventLog == NULL) { hEventLog = RegisterEventSource ( (LPSTR)NULL, // on the local machine
APP_NAME); // register the name to allow message lookup
}
//
// Open the HTTP Server service's Performance key.
//
err = RegOpenKeyEx( HKEY_LOCAL_MACHINE, INFO_PERFORMANCE_KEY, 0, KEY_READ, &hkey );
if( err == NO_ERROR ) { //
// Read the first counter DWORD.
//
size = sizeof(DWORD);
err = RegQueryValueEx( hkey, "First Counter", NULL, &type, (LPBYTE)&dwFirstCounter, &size ); if( err == NO_ERROR ) { //
// Read the first help DWORD.
//
size = sizeof(DWORD);
err = RegQueryValueEx( hkey, "First Help", NULL, &type, (LPBYTE)&dwFirstHelp, &size );
if ( err == NO_ERROR ) { //
// Update the object & counter name & help indicies.
//
INFODataDefinition.INFOObjectType.ObjectNameTitleIndex += dwFirstCounter; INFODataDefinition.INFOObjectType.ObjectHelpTitleIndex += dwFirstHelp;
pctr = &INFODataDefinition.INFOTotalAllowedRequests;
for( i = 0 ; i < NUMBER_OF_INFO_COUNTERS ; i++ ) { pctr->CounterNameTitleIndex += dwFirstCounter; pctr->CounterHelpTitleIndex += dwFirstHelp; pctr++; }
//
// Remember that we initialized OK.
//
fInitOK = TRUE; //
// Bump open counter.
//
cOpens++;
// return success
err = ERROR_SUCCESS; } else { // log event
ReportEvent (hEventLog, EVENTLOG_ERROR_TYPE, 0, IIS_INFO_UNABLE_READ_FIRST_HELP, (PSID)NULL, 0, sizeof (err), NULL, (PVOID)(&err)); } } else { // log event
ReportEvent (hEventLog, EVENTLOG_ERROR_TYPE, 0, IIS_INFO_UNABLE_READ_FIRST_COUNTER, (PSID)NULL, 0, sizeof (err), NULL, (PVOID)(&err)); } //
// Close the registry if we managed to actually open it.
//
if( hkey != NULL ) { RegCloseKey( hkey ); hkey = NULL; } } else { // log event
ReportEvent (hEventLog, EVENTLOG_ERROR_TYPE, 0, IIS_INFO_UNABLE_OPEN_PERF_KEY, (PSID)NULL, 0, sizeof (err), NULL, (PVOID)(&err)); } }
return err;
} // OpenINFOPerformanceData
/*******************************************************************
NAME: CollectINFOPerformanceData
SYNOPSIS: Initializes the data structures used to communicate
ENTRY: lpValueName - The name of the value to retrieve.
lppData - On entry contains a pointer to the buffer to receive the completed PerfDataBlock & subordinate structures. On exit, points to the first bytes *after* the data structures added by this routine.
lpcbTotalBytes - On entry contains a pointer to the size (in BYTEs) of the buffer referenced by lppData. On exit, contains the number of BYTEs added by this routine.
lpNumObjectTypes - Receives the number of objects added by this routine.
RETURNS: DWORD - Win32 status code. MUST be either NO_ERROR or ERROR_MORE_DATA.
HISTORY: KeithMo 07-Jun-1993 Created.
********************************************************************/DWORD CollectINFOPerformanceData( LPWSTR lpValueName, LPVOID * lppData, LPDWORD lpcbTotalBytes, LPDWORD lpNumObjectTypes ){ DWORD dwQueryType; ULONG cbRequired; DWORD * pdwCounter; INFO_COUNTER_BLOCK * pCounterBlock; INFO_DATA_DEFINITION * pINFODataDefinition; INET_INFO_STATISTICS_0 * pINFOStats; NET_API_STATUS neterr;
//
// No need to even try if we failed to open...
//
if( !fInitOK ) { *lpcbTotalBytes = 0; *lpNumObjectTypes = 0;
//
// According to the Performance Counter design, this
// is a successful exit. Go figure.
//
return NO_ERROR; }
//
// Determine the query type.
//
dwQueryType = GetQueryType( lpValueName );
if (( dwQueryType == QUERY_FOREIGN ) || ( dwQueryType == QUERY_COSTLY )) { //
// We don't do foreign or Costly queries.
//
*lpcbTotalBytes = 0; *lpNumObjectTypes = 0;
return NO_ERROR; }
if( dwQueryType == QUERY_ITEMS ) { //
// The registry is asking for a specific object. Let's
// see if we're one of the chosen.
//
if( !IsNumberInUnicodeList( INFODataDefinition.INFOObjectType.ObjectNameTitleIndex, lpValueName ) ) { *lpcbTotalBytes = 0; *lpNumObjectTypes = 0;
return NO_ERROR; } }
//
// See if there's enough space.
//
pINFODataDefinition = (INFO_DATA_DEFINITION *)*lppData;
//
// Try to retrieve the data.
//
neterr = InetInfoQueryStatistics( NULL, 0, 0, (LPBYTE *)&pINFOStats );
if( neterr == NERR_Success ) {
cbRequired = sizeof(INFO_DATA_DEFINITION) + SIZE_OF_INFO_PERFORMANCE_DATA;
if( *lpcbTotalBytes < cbRequired ) { //
// Nope.
//
*lpcbTotalBytes = 0; *lpNumObjectTypes = 0;
return ERROR_MORE_DATA; }
//
// Copy the (constant, initialized) Object Type and counter definitions
// to the caller's data buffer
//
memmove( pINFODataDefinition, &INFODataDefinition, sizeof(INFO_DATA_DEFINITION) );
//
// Format the INFO Server data.
//
pCounterBlock = (INFO_COUNTER_BLOCK *)( pINFODataDefinition + 1 );
pCounterBlock->PerfCounterBlock.ByteLength = SIZE_OF_INFO_PERFORMANCE_DATA;
//
// Now move the DWORDs into the buffer.
//
pdwCounter = (DWORD *)(pCounterBlock + 1);
//
// ATQ Global counters
//
*pdwCounter++ = pINFOStats->AtqCtrs.TotalAllowedRequests; *pdwCounter++ = pINFOStats->AtqCtrs.TotalBlockedRequests; *pdwCounter++ = pINFOStats->AtqCtrs.TotalRejectedRequests; *pdwCounter++ = pINFOStats->AtqCtrs.CurrentBlockedRequests; *pdwCounter++ = pINFOStats->AtqCtrs.MeasuredBandwidth;
//
// File Handle Cache counters
//
*pdwCounter++ = pINFOStats->CacheCtrs.FilesCached; *pdwCounter++ = pINFOStats->CacheCtrs.TotalFilesCached; *pdwCounter++ = pINFOStats->CacheCtrs.FileHits; *pdwCounter++ = pINFOStats->CacheCtrs.FileMisses; *pdwCounter++ = pINFOStats->CacheCtrs.FileHits; *pdwCounter++ = ( pINFOStats->CacheCtrs.FileHits + pINFOStats->CacheCtrs.FileMisses); *pdwCounter++ = pINFOStats->CacheCtrs.FileFlushes;
// 64BIT BUGBUG: need to change the caller to expect int64 and then
// put in the whole 64 bit value here
// *((DWORDLONG *)pdwCounter) =
*pdwCounter++ = (DWORD)pINFOStats->CacheCtrs.CurrentFileCacheSize;
// pdwCounter += sizeof(DWORDLONG) / sizeof(*pdwCounter);
// *((DWORDLONG *)pdwCounter) =
*pdwCounter++ = (DWORD)pINFOStats->CacheCtrs.MaximumFileCacheSize;
// pdwCounter += sizeof(DWORDLONG) / sizeof(*pdwCounter);
*pdwCounter++ = pINFOStats->CacheCtrs.FlushedEntries; *pdwCounter++ = pINFOStats->CacheCtrs.TotalFlushed;
//
// URI Cache counters
//
*pdwCounter++ = pINFOStats->CacheCtrs.URICached; *pdwCounter++ = pINFOStats->CacheCtrs.TotalURICached; *pdwCounter++ = pINFOStats->CacheCtrs.URIHits; *pdwCounter++ = pINFOStats->CacheCtrs.URIMisses; *pdwCounter++ = pINFOStats->CacheCtrs.URIHits; *pdwCounter++ = ( pINFOStats->CacheCtrs.URIHits + pINFOStats->CacheCtrs.URIMisses); *pdwCounter++ = pINFOStats->CacheCtrs.URIFlushes; *pdwCounter++ = pINFOStats->CacheCtrs.TotalURIFlushed;
//
// Blob Cache Counters
//
*pdwCounter++ = pINFOStats->CacheCtrs.BlobCached; *pdwCounter++ = pINFOStats->CacheCtrs.TotalBlobCached; *pdwCounter++ = pINFOStats->CacheCtrs.BlobHits; *pdwCounter++ = pINFOStats->CacheCtrs.BlobMisses; *pdwCounter++ = pINFOStats->CacheCtrs.BlobHits; *pdwCounter++ = ( pINFOStats->CacheCtrs.BlobHits + pINFOStats->CacheCtrs.BlobMisses); *pdwCounter++ = pINFOStats->CacheCtrs.BlobFlushes; *pdwCounter++ = pINFOStats->CacheCtrs.TotalBlobFlushed;
//
// Update arguments for return.
//
*lppData = (PVOID)pdwCounter; *lpNumObjectTypes = 1; *lpcbTotalBytes = DIFF((BYTE *)pdwCounter - (BYTE *)pINFODataDefinition);
//
// Free the API buffer.
//
MIDL_user_free( (LPBYTE)pINFOStats );
//
// Success! Honest!!
//
} else { //
// Error retrieving statistics.
//
// if the server is down, we don't log an error.
if ( !( neterr == RPC_S_SERVER_UNAVAILABLE || neterr == RPC_S_UNKNOWN_IF || neterr == ERROR_SERVICE_NOT_ACTIVE || neterr == RPC_S_CALL_FAILED_DNE )) {
// log event
ReportEvent (hEventLog, EVENTLOG_ERROR_TYPE, 0, IIS_INFO_UNABLE_QUERY_IIS_INFO_DATA, (PSID)NULL, 0, sizeof (neterr), NULL, (PVOID)(&neterr)); }
cbRequired = sizeof(INFO_DATA_DEFINITION) + SIZE_OF_INFO_PERFORMANCE_DATA;
if( *lpcbTotalBytes < cbRequired ) { //
// Nope.
//
*lpcbTotalBytes = 0; *lpNumObjectTypes = 0;
return ERROR_MORE_DATA; }
// Attempt to atlest provide the definition
// for the counters. This is so WMI can know
// that these counters exist.
memmove( pINFODataDefinition, &INFODataDefinition, sizeof(INFO_DATA_DEFINITION) );
((PERF_OBJECT_TYPE*) pINFODataDefinition)->NumInstances = PERF_NO_INSTANCES; ((PERF_OBJECT_TYPE*) pINFODataDefinition)->TotalByteLength = cbRequired;
// Copy in the actual data for global
memset ( (LPVOID) ( pINFODataDefinition + 1 ), 0, SIZE_OF_INFO_PERFORMANCE_DATA );
// This is setting the size in the structure, it is the first
// DWORD in the INFO_COUNTER_BLOCK.
*((DWORD*) (pINFODataDefinition + 1)) = SIZE_OF_INFO_PERFORMANCE_DATA;
*lpcbTotalBytes = cbRequired; *lpNumObjectTypes = 1; *lppData = (LPBYTE) pINFODataDefinition + cbRequired;
}
return NO_ERROR;
} // CollectINFOPerformanceData
/*******************************************************************
NAME: CloseINFOPerformanceData
SYNOPSIS: Terminates the performance counters.
RETURNS: DWORD - Win32 status code.
HISTORY: KeithMo 07-Jun-1993 Created.
********************************************************************/DWORD CloseINFOPerformanceData( VOID ){ //
// No real cleanup to do here.
//
if (--cOpens == 0) { if (hEventLog != NULL) DeregisterEventSource (hEventLog); }
return NO_ERROR;
} // CloseINFOPerformanceData
|
