1622 lines
71 KiB
C
1622 lines
71 KiB
C
/*++
|
||
|
||
Copyright (c) 1998 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
dnsperf.c
|
||
|
||
Abstract:
|
||
|
||
This file implements the Extensible Objects for the DNS object type
|
||
|
||
Created:
|
||
|
||
Jing Chen 1998
|
||
|
||
Revision History
|
||
|
||
--*/
|
||
|
||
|
||
//
|
||
// Include Files
|
||
//
|
||
|
||
#include <nt.h>
|
||
#include <ntrtl.h>
|
||
#include <nturtl.h>
|
||
#include <windows.h>
|
||
#include <rpc.h>
|
||
|
||
#include <wchar.h>
|
||
#include <winperf.h>
|
||
|
||
|
||
#include "perfutil.h"
|
||
#include "datadns.h"
|
||
#include "dnsperf.h"
|
||
#include "perfconfig.h"
|
||
#include "dnslibp.h" // security routine
|
||
|
||
#define SERVICE_NAME "DNS"
|
||
|
||
|
||
//
|
||
// DNS counter data structures
|
||
//
|
||
|
||
DWORD dwOpenCount = 0; // count of "Open" threads
|
||
BOOL bInitOK = FALSE; // true = DLL initialized OK
|
||
|
||
HANDLE hDnsSharedMemory = NULL; // Handle of Dns Shared Memory
|
||
PDWORD pCounterBlock = NULL;
|
||
|
||
extern DNS_DATA_DEFINITION DnsDataDefinition;
|
||
|
||
//
|
||
// Function Prototypes
|
||
//
|
||
// these are used to insure that the data collection functions
|
||
// accessed by Perflib will have the correct calling format.
|
||
//
|
||
|
||
PM_OPEN_PROC OpenDnsPerformanceData;
|
||
PM_COLLECT_PROC CollectDnsPerformanceData;
|
||
PM_CLOSE_PROC CloseDnsPerformanceData;
|
||
|
||
|
||
|
||
|
||
DWORD
|
||
OpenDnsPerformanceData(
|
||
IN LPWSTR lpDeviceNames
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will open and map the memory used by the DNS to
|
||
pass performance data in. 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 (DNS), which
|
||
seems to be totally unused, just as it was in the sample code
|
||
from which this is stolen.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
{
|
||
LONG status;
|
||
HKEY hKeyDriverPerf = NULL;
|
||
DWORD size;
|
||
DWORD type;
|
||
DWORD dwFirstCounter;
|
||
DWORD dwFirstHelp;
|
||
|
||
//
|
||
// 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
|
||
//
|
||
// DNS_FIX0: possible MT issues in dnsperf
|
||
// - thread counter is not protected, needs Interlocked instruction
|
||
// - contrary to above, reentrancy is not protected as we do
|
||
// file mapping first
|
||
// - file mapping not cleaned up on failure
|
||
// - registry handle not cleaned up on failure
|
||
//
|
||
|
||
if ( !dwOpenCount )
|
||
{
|
||
// open shared memory used by device driver to pass performance values
|
||
|
||
hDnsSharedMemory = OpenFileMapping(
|
||
FILE_MAP_READ,
|
||
FALSE,
|
||
DNS_PERF_COUNTER_BLOCK );
|
||
|
||
pCounterBlock = NULL; // initialize pointer to memory
|
||
|
||
if ( hDnsSharedMemory == NULL )
|
||
{
|
||
#if 0
|
||
//
|
||
// kill off NULL DACL code
|
||
//
|
||
|
||
/* maybe the DNS isn't running, and we should alloc the memory? */
|
||
SECURITY_ATTRIBUTES SA, *pSA;
|
||
BYTE rgbSD[SECURITY_DESCRIPTOR_MIN_LENGTH];
|
||
PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR) rgbSD;
|
||
|
||
pSA = &SA;
|
||
pSA->nLength = sizeof(SA);
|
||
pSA->lpSecurityDescriptor = pSD;
|
||
pSA->bInheritHandle = FALSE;
|
||
|
||
if ( !InitializeSecurityDescriptor(
|
||
pSD,
|
||
SECURITY_DESCRIPTOR_REVISION) ||
|
||
! SetSecurityDescriptorDacl( pSD, TRUE, (PACL) NULL, FALSE) )
|
||
{
|
||
pSA = NULL;
|
||
}
|
||
#endif
|
||
//
|
||
// create security on perfmon mapped file
|
||
//
|
||
// security will be AuthenticatedUsers get to read
|
||
// note, using array syntax, to make it easier to tweak
|
||
// if want other ACLs later
|
||
//
|
||
|
||
SID_IDENTIFIER_AUTHORITY ntAuthority = SECURITY_NT_AUTHORITY;
|
||
SECURITY_ATTRIBUTES secAttr;
|
||
PSECURITY_ATTRIBUTES psecAttr = NULL;
|
||
PSECURITY_DESCRIPTOR psd = NULL;
|
||
DWORD maskArray[ 3 ] = { 0 };
|
||
PSID sidArray[ 3 ] = { 0 }; // NULL terminated!
|
||
INT i;
|
||
|
||
maskArray[ 0 ] = GENERIC_READ;
|
||
status = RtlAllocateAndInitializeSid(
|
||
&ntAuthority,
|
||
1,
|
||
SECURITY_AUTHENTICATED_USER_RID,
|
||
0, 0, 0, 0, 0, 0, 0,
|
||
&sidArray[ 0 ] );
|
||
if ( status != ERROR_SUCCESS )
|
||
{
|
||
maskArray[ 1 ] = GENERIC_ALL;
|
||
status = RtlAllocateAndInitializeSid(
|
||
&ntAuthority,
|
||
1,
|
||
SECURITY_LOCAL_SYSTEM_RID,
|
||
0, 0, 0, 0, 0, 0, 0,
|
||
&sidArray[ 1 ] );
|
||
}
|
||
if ( status != ERROR_SUCCESS )
|
||
{
|
||
DNS_PRINT((
|
||
"ERROR <%lu>: Cannot create Authenticated Users SID\n",
|
||
status ));
|
||
}
|
||
else
|
||
{
|
||
status = Dns_CreateSecurityDescriptor(
|
||
&psd,
|
||
2, // number of ACEs
|
||
sidArray,
|
||
maskArray );
|
||
|
||
if ( status == ERROR_SUCCESS )
|
||
{
|
||
secAttr.lpSecurityDescriptor = psd;
|
||
secAttr.bInheritHandle = FALSE;
|
||
secAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
|
||
psecAttr = &secAttr;
|
||
}
|
||
ELSE
|
||
{
|
||
DNSDBG( ANY, (
|
||
"ERROR: <%d> failed SD create for perfmon memory!\n",
|
||
status ));
|
||
}
|
||
}
|
||
|
||
hDnsSharedMemory = CreateFileMapping(
|
||
(HANDLE) (-1),
|
||
psecAttr,
|
||
PAGE_READWRITE,
|
||
0,
|
||
4096,
|
||
DNS_PERF_COUNTER_BLOCK);
|
||
|
||
for ( i = 0; sidArray[ i ]; ++i )
|
||
{
|
||
RtlFreeSid( sidArray[ i ] );
|
||
}
|
||
if ( psd )
|
||
{
|
||
Dns_Free( psd );
|
||
}
|
||
}
|
||
|
||
// log error if unsuccessful
|
||
|
||
if ( hDnsSharedMemory == NULL )
|
||
{
|
||
// this is fatal, if we can't get data then there's no
|
||
// point in continuing.
|
||
status = GetLastError(); // return error
|
||
goto OpenFailed;
|
||
}
|
||
else
|
||
{
|
||
// if opened ok, then map pointer to memory
|
||
pCounterBlock = (PDWORD) MapViewOfFile(
|
||
hDnsSharedMemory,
|
||
FILE_MAP_READ,
|
||
0,
|
||
0,
|
||
0);
|
||
|
||
if (pCounterBlock == NULL)
|
||
{
|
||
// this is fatal, if we can't get data then there's no
|
||
// point in continuing.
|
||
status = GetLastError(); // return error
|
||
goto OpenFailed;
|
||
}
|
||
}
|
||
|
||
// 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\\" SERVICE_NAME "\\Performance",
|
||
0L,
|
||
KEY_READ,
|
||
&hKeyDriverPerf);
|
||
|
||
if (status != ERROR_SUCCESS)
|
||
{
|
||
LPTSTR apsz[2];
|
||
|
||
// 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.
|
||
apsz[0] = (LPTSTR) (LONG_PTR) status;
|
||
apsz[1] = "SYSTEM\\CurrentControlSet\\Services\\" SERVICE_NAME "\\Performance";
|
||
goto OpenFailed;
|
||
}
|
||
|
||
size = sizeof (DWORD);
|
||
status = RegQueryValueEx(
|
||
hKeyDriverPerf,
|
||
"First Counter",
|
||
0L,
|
||
&type,
|
||
(LPBYTE)&dwFirstCounter,
|
||
&size);
|
||
|
||
if (status != ERROR_SUCCESS) {
|
||
LPTSTR apsz[2];
|
||
|
||
// 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.
|
||
apsz[0] = (LPTSTR) (LONG_PTR) status;
|
||
apsz[1] = "First Counter";
|
||
goto OpenFailed;
|
||
}
|
||
|
||
size = sizeof (DWORD);
|
||
status = RegQueryValueEx(
|
||
hKeyDriverPerf,
|
||
"First Help",
|
||
0L,
|
||
&type,
|
||
(LPBYTE)&dwFirstHelp,
|
||
&size);
|
||
|
||
if (status != ERROR_SUCCESS)
|
||
{
|
||
LPTSTR apsz[2];
|
||
|
||
// 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.
|
||
apsz[0] = (LPTSTR) (LONG_PTR) status;
|
||
apsz[1] = "First Help";
|
||
goto OpenFailed;
|
||
}
|
||
|
||
//
|
||
// NOTE: the initialization program could also retrieve
|
||
// LastCounter and LastHelp if they wanted to do
|
||
// bounds checking on the new number. e.g.
|
||
//
|
||
// counter->CounterNameTitleIndex += dwFirstCounter;
|
||
// if (counter->CounterNameTitleIndex > dwLastCounter) {
|
||
// LogErrorToEventLog (INDEX_OUT_OF_BOUNDS);
|
||
// }
|
||
|
||
DnsDataDefinition.DnsObjectType.ObjectNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DnsObjectType.ObjectHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TotalQueryReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TotalQueryReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TotalQueryReceived_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TotalQueryReceived_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.UdpQueryReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.UdpQueryReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.UdpQueryReceived_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.UdpQueryReceived_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TcpQueryReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TcpQueryReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TcpQueryReceived_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TcpQueryReceived_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TotalResponseSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TotalResponseSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TotalResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TotalResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.UdpResponseSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.UdpResponseSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.UdpResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.UdpResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TcpResponseSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TcpResponseSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TcpResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TcpResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.RecursiveQueries.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.RecursiveQueries.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.RecursiveQueries_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.RecursiveQueries_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.RecursiveTimeOut.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.RecursiveTimeOut.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.RecursiveTimeOut_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.RecursiveTimeOut_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.RecursiveQueryFailure.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.RecursiveQueryFailure.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.RecursiveQueryFailure_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.RecursiveQueryFailure_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.NotifySent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.NotifySent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.ZoneTransferRequestReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.ZoneTransferRequestReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.ZoneTransferSuccess.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.ZoneTransferSuccess.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.ZoneTransferFailure.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.ZoneTransferFailure.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.AxfrRequestReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.AxfrRequestReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.AxfrSuccessSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.AxfrSuccessSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.IxfrRequestReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.IxfrRequestReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.IxfrSuccessSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.IxfrSuccessSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.NotifyReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.NotifyReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.ZoneTransferSoaRequestSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.ZoneTransferSoaRequestSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.AxfrRequestSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.AxfrRequestSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.AxfrResponseReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.AxfrResponseReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.AxfrSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.AxfrSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.IxfrRequestSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.IxfrRequestSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.IxfrResponseReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.IxfrResponseReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.IxfrSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.IxfrSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.IxfrUdpSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.IxfrUdpSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.IxfrTcpSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.IxfrTcpSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsLookupReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsLookupReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsLookupReceived_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsLookupReceived_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsResponseSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsResponseSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsReverseLookupReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsReverseLookupReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsReverseLookupReceived_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsReverseLookupReceived_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsReverseResponseSent.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsReverseResponseSent.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.WinsReverseResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.WinsReverseResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateReceived_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateReceived_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateNoOp.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateNoOp.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateNoOp_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateNoOp_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateWriteToDB.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateWriteToDB.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateWriteToDB_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateWriteToDB_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateRejected.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateRejected.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateTimeOut.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateTimeOut.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DynamicUpdateQueued.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DynamicUpdateQueued.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.SecureUpdateReceived.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.SecureUpdateReceived.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.SecureUpdateReceived_s.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.SecureUpdateReceived_s.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.SecureUpdateFailure.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.SecureUpdateFailure.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.DatabaseNodeMemory.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.DatabaseNodeMemory.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.RecordFlowMemory.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.RecordFlowMemory.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.CachingMemory.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.CachingMemory.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.UdpMessageMemory.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.UdpMessageMemory.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.TcpMessageMemory.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.TcpMessageMemory.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
DnsDataDefinition.NbstatMemory.CounterNameTitleIndex += dwFirstCounter;
|
||
DnsDataDefinition.NbstatMemory.CounterHelpTitleIndex += dwFirstHelp;
|
||
|
||
RegCloseKey( hKeyDriverPerf ); // close key to registry
|
||
|
||
bInitOK = TRUE; // ok to use this function
|
||
}
|
||
|
||
dwOpenCount++; // increment OPEN counter
|
||
|
||
return( ERROR_SUCCESS ); // for successful exit
|
||
|
||
|
||
OpenFailed:
|
||
|
||
//
|
||
// close handles if open fails
|
||
//
|
||
|
||
if ( hKeyDriverPerf )
|
||
{
|
||
RegCloseKey( hKeyDriverPerf );
|
||
}
|
||
if ( pCounterBlock )
|
||
{
|
||
UnmapViewOfFile( pCounterBlock );
|
||
pCounterBlock = NULL;
|
||
}
|
||
if ( hDnsSharedMemory )
|
||
{
|
||
CloseHandle( hDnsSharedMemory );
|
||
hDnsSharedMemory = NULL;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
CollectDnsPerformanceData(
|
||
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 DNS 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
|
||
|
||
ULONG SpaceNeeded;
|
||
PDWORD pdwCounter;
|
||
PERF_COUNTER_BLOCK *pPerfCounterBlock;
|
||
DNS_DATA_DEFINITION *pDnsDataDefinition;
|
||
|
||
DWORD dwQueryType; // for error logging
|
||
|
||
//
|
||
// 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 )
|
||
{
|
||
// this routine does not service requests for data from
|
||
// Non-NT computers
|
||
*lpcbTotalBytes = (DWORD) 0;
|
||
*lpNumObjectTypes = (DWORD) 0;
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
if (dwQueryType == QUERY_ITEMS)
|
||
{
|
||
if ( ! IsNumberInUnicodeList(
|
||
DnsDataDefinition.DnsObjectType.ObjectNameTitleIndex,
|
||
lpValueName ) )
|
||
{
|
||
// request received for data object not provided by this routine
|
||
*lpcbTotalBytes = (DWORD) 0;
|
||
*lpNumObjectTypes = (DWORD) 0;
|
||
return ERROR_SUCCESS;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Get the data.
|
||
//
|
||
|
||
pDnsDataDefinition = (DNS_DATA_DEFINITION *) *lppData;
|
||
|
||
SpaceNeeded = sizeof(DNS_DATA_DEFINITION) + SIZE_OF_DNS_PERFORMANCE_DATA;
|
||
|
||
if ( *lpcbTotalBytes < SpaceNeeded )
|
||
{
|
||
*lpcbTotalBytes = (DWORD) 0;
|
||
*lpNumObjectTypes = (DWORD) 0;
|
||
return ERROR_MORE_DATA;
|
||
}
|
||
|
||
//
|
||
// Copy the (constant, initialized) Object Type and counter definitions
|
||
// to the caller's data buffer
|
||
//
|
||
|
||
memmove(pDnsDataDefinition,
|
||
&DnsDataDefinition,
|
||
sizeof(DNS_DATA_DEFINITION));
|
||
|
||
// Format and collect DNS data from shared memory
|
||
|
||
// The counter block is to immediately follow the data definition,
|
||
// so obtain a pointer to that space
|
||
pPerfCounterBlock = (PERF_COUNTER_BLOCK *) &pDnsDataDefinition[1];
|
||
|
||
// The byte length is of the counter block header and all following data
|
||
pPerfCounterBlock->ByteLength = SIZE_OF_DNS_PERFORMANCE_DATA;
|
||
|
||
// Compute a pointer to the buffer immediately following the counter
|
||
// block header
|
||
pdwCounter = (PDWORD) (&pPerfCounterBlock[1]);
|
||
|
||
// copy the counter data from shared memory block into the counter block
|
||
memcpy(pdwCounter,
|
||
&pCounterBlock[1],
|
||
SIZE_OF_DNS_PERFORMANCE_DATA - sizeof(PERF_COUNTER_BLOCK));
|
||
|
||
// Tell caller where the next available byte is
|
||
*lppData = (PVOID) ((PBYTE)pdwCounter + SIZE_OF_DNS_PERFORMANCE_DATA - sizeof(PERF_COUNTER_BLOCK));
|
||
|
||
// update arguments before return
|
||
|
||
*lpNumObjectTypes = 1;
|
||
|
||
*lpcbTotalBytes = (DWORD) ((PBYTE)*lppData - (PBYTE)pDnsDataDefinition);
|
||
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
CloseDnsPerformanceData(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine closes the open handles to DNS device performance counters
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS
|
||
|
||
--*/
|
||
{
|
||
//
|
||
// cleanup when close last thread
|
||
//
|
||
// DNS_FIX0: MT issues in dnsperf cleanup
|
||
// no real protection on thread count (need interlock)
|
||
// but also close can be going on concurrently with another
|
||
// thread attempting to reopen (unlikely but possible)
|
||
//
|
||
// perhaps two flag approach would work, with all new threads
|
||
// failing (not passing through but skipping open altogether)
|
||
// until pCounterBlock was NULL again
|
||
//
|
||
|
||
if ( !(--dwOpenCount) )
|
||
{
|
||
// clear bInitOk, as otherwise collect function
|
||
// will attempt to reference into pCounterBlock
|
||
|
||
bInitOK = FALSE;
|
||
|
||
if ( pCounterBlock )
|
||
{
|
||
UnmapViewOfFile( pCounterBlock );
|
||
pCounterBlock = NULL;
|
||
}
|
||
if ( hDnsSharedMemory )
|
||
{
|
||
CloseHandle( hDnsSharedMemory );
|
||
hDnsSharedMemory = NULL;
|
||
}
|
||
}
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
|
||
//
|
||
// Data for this whole thing to work on
|
||
//
|
||
|
||
DNS_DATA_DEFINITION DnsDataDefinition =
|
||
{
|
||
// DNS obj for PerfMon:
|
||
{ sizeof(DNS_DATA_DEFINITION) + SIZE_OF_DNS_PERFORMANCE_DATA, // TotLen
|
||
sizeof(DNS_DATA_DEFINITION), // DefinitionLength
|
||
sizeof(PERF_OBJECT_TYPE), // HeaderLength
|
||
DNSOBJ, // ObjectNameTitleIndex
|
||
0, // ObjectNameTitle
|
||
DNSOBJ, // ObjectHelpTitleIndex
|
||
0, // ObjectHelpTitle
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
(sizeof(DNS_DATA_DEFINITION)-sizeof(PERF_OBJECT_TYPE))/
|
||
sizeof(PERF_COUNTER_DEFINITION), // NumCounters
|
||
0, // DefaultCounter
|
||
-1, // NumInstances
|
||
0 // CodePage (0=Unicode)
|
||
},
|
||
|
||
// total query received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TOTALQUERYRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TOTALQUERYRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TOTALQUERYRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// total qurey received/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TOTALQUERYRECEIVED_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TOTALQUERYRECEIVED_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TOTALQUERYRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// UDP query received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
UDPQUERYRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
UDPQUERYRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
UDPQUERYRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// UDP query received/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
UDPQUERYRECEIVED_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
UDPQUERYRECEIVED_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
UDPQUERYRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// TCP query received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TCPQUERYRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TCPQUERYRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TCPQUERYRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// TCP query received/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TCPQUERYRECEIVED_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TCPQUERYRECEIVED_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TCPQUERYRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// total response sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TOTALRESPONSESENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TOTALRESPONSESENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TOTALRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// total response sent/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TOTALRESPONSESENT_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TOTALRESPONSESENT_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TOTALRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// UDP response sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
UDPRESPONSESENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
UDPRESPONSESENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
UDPRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// UDP response sent/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
UDPRESPONSESENT_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
UDPRESPONSESENT_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
UDPRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// TCP response sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TCPRESPONSESENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TCPRESPONSESENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TCPRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// TCP response sent/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TCPRESPONSESENT_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TCPRESPONSESENT_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TCPRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// recursive query received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
RECURSIVEQUERIES, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
RECURSIVEQUERIES, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
RECURSIVEQUERIES_OFFSET // CounterOffset
|
||
},
|
||
|
||
// recursive query received/s
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
RECURSIVEQUERIES_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
RECURSIVEQUERIES_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
RECURSIVEQUERIES_OFFSET // CounterOffset
|
||
},
|
||
|
||
// recursive query timeout
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
RECURSIVETIMEOUT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
RECURSIVETIMEOUT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
RECURSIVETIMEOUT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// recursive query timeout/s
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
RECURSIVETIMEOUT_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
RECURSIVETIMEOUT_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
RECURSIVETIMEOUT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// recursive query failure
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
RECURSIVEQUERYFAILURE, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
RECURSIVEQUERYFAILURE, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
RECURSIVEQUERYFAILURE_OFFSET // CounterOffset
|
||
},
|
||
|
||
// recursive query failure/s
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
RECURSIVEQUERYFAILURE_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
RECURSIVEQUERYFAILURE_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
RECURSIVEQUERYFAILURE_OFFSET // CounterOffset
|
||
},
|
||
|
||
// notify sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
NOTIFYSENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
NOTIFYSENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
NOTIFYSENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// zone transfer request received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
ZONETRANSFERREQUESTRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
ZONETRANSFERREQUESTRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
ZONETRANSFERREQUESTRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// zone transfer success
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
ZONETRANSFERSUCCESS, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
ZONETRANSFERSUCCESS, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
ZONETRANSFERSUCCESS_OFFSET // CounterOffset
|
||
},
|
||
|
||
// zone transfer failure
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
ZONETRANSFERFAILURE, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
ZONETRANSFERFAILURE, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
ZONETRANSFERFAILURE_OFFSET // CounterOffset
|
||
},
|
||
|
||
// AXFR request received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
AXFRREQUESTRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
AXFRREQUESTRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
AXFRREQUESTRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// AXFR success sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
AXFRSUCCESSSENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
AXFRSUCCESSSENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
AXFRSUCCESSSENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// IXFR request received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
IXFRREQUESTRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
IXFRREQUESTRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
IXFRREQUESTRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// IXFR success sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
IXFRSUCCESSSENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
IXFRSUCCESSSENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
IXFRSUCCESSSENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// notify received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
NOTIFYRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
NOTIFYRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
NOTIFYRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// zone transfer SOA request sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
ZONETRANSFERSOAREQUESTSENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
ZONETRANSFERSOAREQUESTSENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
ZONETRANSFERSOAREQUESTSENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// AXFR request sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
AXFRREQUESTSENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
AXFRREQUESTSENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
AXFRREQUESTSENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// AXFR response received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
AXFRRESPONSERECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
AXFRRESPONSERECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
AXFRRESPONSERECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// AXFR success received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
AXFRSUCCESSRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
AXFRSUCCESSRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
AXFRSUCCESSRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// IXFR request sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
IXFRREQUESTSENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
IXFRREQUESTSENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
IXFRREQUESTSENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// IXFR response received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
IXFRRESPONSERECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
IXFRRESPONSERECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
IXFRRESPONSERECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// IXFR succes received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
IXFRSUCCESSRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
IXFRSUCCESSRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
IXFRSUCCESSRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// IXFR UDP success received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
IXFRUDPSUCCESSRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
IXFRUDPSUCCESSRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
IXFRUDPSUCCESSRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// IXFR TCP success received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
IXFRTCPSUCCESSRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
IXFRTCPSUCCESSRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
IXFRTCPSUCCESSRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS lookup request received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSLOOKUPRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSLOOKUPRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSLOOKUPRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS lookup request received/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSLOOKUPRECEIVED_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSLOOKUPRECEIVED_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSLOOKUPRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS response sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSRESPONSESENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSRESPONSESENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS response sent/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSRESPONSESENT_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSRESPONSESENT_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSRESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS reverse lookup received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSREVERSELOOKUPRECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSREVERSELOOKUPRECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSREVERSELOOKUPRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS reverse lookup received/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSREVERSELOOKUPRECEIVED_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSREVERSELOOKUPRECEIVED_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSREVERSELOOKUPRECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS reverse response sent
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSREVERSERESPONSESENT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSREVERSERESPONSESENT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSREVERSERESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// WINS reverse response sent/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
WINSREVERSERESPONSESENT_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
WINSREVERSERESPONSESENT_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
WINSREVERSERESPONSESENT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATERECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATERECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATERECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update received/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATERECEIVED_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATERECEIVED_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATERECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update NoOperation & Empty
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATENOOP, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATENOOP, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATENOOP_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update NoOperation & Empty/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATENOOP_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATENOOP_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATENOOP_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update write to database (completed)
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATEWRITETODB, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATEWRITETODB, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATEWRITETODB_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update write to database (completed)/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATEWRITETODB_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATEWRITETODB_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATEWRITETODB_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update rejected
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATEREJECTED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATEREJECTED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATEREJECTED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update timeout
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATETIMEOUT, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATETIMEOUT, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATETIMEOUT_OFFSET // CounterOffset
|
||
},
|
||
|
||
// dynamic update queued
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DYNAMICUPDATEQUEUED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DYNAMICUPDATEQUEUED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DYNAMICUPDATEQUEUED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// secure update received
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
SECUREUPDATERECEIVED, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
SECUREUPDATERECEIVED, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
SECUREUPDATERECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// secure update received/sec
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
SECUREUPDATERECEIVED_S, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
SECUREUPDATERECEIVED_S, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_COUNTER, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
SECUREUPDATERECEIVED_OFFSET // CounterOffset
|
||
},
|
||
|
||
// secure update failure
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
SECUREUPDATEFAILURE, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
SECUREUPDATEFAILURE, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
SECUREUPDATEFAILURE_OFFSET // CounterOffset
|
||
},
|
||
|
||
// database node memory
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
DATABASENODEMEMORY, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
DATABASENODEMEMORY, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
DATABASENODEMEMORY_OFFSET // CounterOffset
|
||
},
|
||
|
||
// record flow memory
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
RECORDFLOWMEMORY, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
RECORDFLOWMEMORY, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
RECORDFLOWMEMORY_OFFSET // CounterOffset
|
||
},
|
||
|
||
// caching memory
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
CACHINGMEMORY, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
CACHINGMEMORY, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
CACHINGMEMORY_OFFSET // CounterOffset
|
||
},
|
||
|
||
// UDP message memory
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
UDPMESSAGEMEMORY, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
UDPMESSAGEMEMORY, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
UDPMESSAGEMEMORY_OFFSET // CounterOffset
|
||
},
|
||
|
||
// TCP message memory
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
TCPMESSAGEMEMORY, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
TCPMESSAGEMEMORY, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
TCPMESSAGEMEMORY_OFFSET // CounterOffset
|
||
},
|
||
|
||
// Nbstat memory
|
||
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
|
||
NBSTATMEMORY, // CounterNameTitleIndex
|
||
0, // CounterNameTitle
|
||
NBSTATMEMORY, // CounterHelpTitleIndex
|
||
0, // CounterHelpTitle
|
||
0, // DefaultScale
|
||
PERF_DETAIL_NOVICE, // DetailLevel
|
||
PERF_COUNTER_RAWCOUNT, // CounterType
|
||
sizeof(DWORD), // CounterSize
|
||
NBSTATMEMORY_OFFSET // CounterOffset
|
||
},
|
||
|
||
|
||
};
|
||
|
||
int APIENTRY _CRT_INIT(
|
||
HANDLE hInstance,
|
||
DWORD ulReasonBeingCalled,
|
||
LPVOID lpReserved);
|
||
|
||
|
||
int __stdcall LibMain(
|
||
HANDLE hInstance,
|
||
DWORD ulReasonBeingCalled,
|
||
LPVOID lpReserved)
|
||
{
|
||
return (_CRT_INIT(hInstance, ulReasonBeingCalled,lpReserved));
|
||
}
|
||
|
||
//
|
||
// End dnsperf.c
|
||
//
|