able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/screg/winreg/perflib/perflib.c

1919 lines
62 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++ BUILD Version: 0001 // Increment this if a change has global effects
Copyright (c) 1992-1994 Microsoft Corporation
Module Name:
perflib.c
Abstract:
This file implements the Configuration Registry
for the purposes of the Performance Monitor.
This file contains the code which implements the Performance part
of the Configuration Registry.
Author:
Russ Blake 11/15/91
Revision History:
04/20/91 - russbl - Converted to lib in Registry
from stand-alone .dll form.
11/04/92 - a-robw - added pagefile and image counter routines
11/01/96 - bobw - revamped to support dynamic loading and
unloading of performance modules
--*/
#define UNICODE
//
// Include files
//
#pragma warning(disable:4306)
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntregapi.h>
#include <ntprfctr.h>
#include <windows.h>
#include <string.h>
#include <stdlib.h>
#include <winperf.h>
#include <rpc.h>
#include "regrpc.h"
#include "ntconreg.h"
#include "prflbmsg.h" // event log messages
#include <initguid.h>
#include <guiddef.h>
#define _INIT_WINPERFP_
#include "perflib.h"
#pragma warning (default:4306)
#define NUM_VALUES 2
//
// performance gathering thead priority
//
#define DEFAULT_THREAD_PRIORITY THREAD_BASE_PRIORITY_LOWRT
//
// constants
//
const WCHAR DLLValue[] = L"Library";
const CHAR OpenValue[] = "Open";
const CHAR CloseValue[] = "Close";
const CHAR CollectValue[] = "Collect";
const CHAR QueryValue[] = "Query";
const WCHAR ObjListValue[] = L"Object List";
const WCHAR LinkageKey[] = L"\\Linkage";
const WCHAR ExportValue[] = L"Export";
const WCHAR PerflibKey[] = L"\\Registry\\Machine\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib";
const WCHAR HKLMPerflibKey[] = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib";
const WCHAR CounterValue[] = L"Counter";
const WCHAR HelpValue[] = L"Help";
const WCHAR PerfSubKey[] = L"\\Performance";
const WCHAR ExtPath[] = L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services";
const WCHAR OpenTimeout[] = L"Open Timeout";
const WCHAR CollectTimeout[] = L"Collect Timeout";
const WCHAR EventLogLevel[] = L"EventLogLevel";
const WCHAR ExtCounterTestLevel[] = L"ExtCounterTestLevel";
const WCHAR OpenProcedureWaitTime[] = L"OpenProcedureWaitTime";
const WCHAR TotalInstanceName[] = L"TotalInstanceName";
const WCHAR LibraryUnloadTime[] = L"Library Unload Time";
const WCHAR KeepResident[] = L"Keep Library Resident";
const WCHAR NULL_STRING[] = L"\0"; // pointer to null string
const WCHAR UseCollectionThread[] = L"UseCollectionThread";
const WCHAR cszLibraryValidationData[] = L"Library Validation Code";
const WCHAR cszSuccessfulFileData[] = L"Successful File Date";
const WCHAR cszPerflibFlags[] = L"Configuration Flags";
const WCHAR FirstCounter[] = L"First Counter";
const WCHAR LastCounter[] = L"Last Counter";
const WCHAR FirstHelp[] = L"First Help";
const WCHAR LastHelp[] = L"Last Help";
const WCHAR cszFailureCount[] = L"Error Count";
const WCHAR cszFailureLimit[] = L"Error Count Limit";
//
// external variables defined in perfname.c
//
extern WCHAR DefaultLangId[];
WCHAR NativeLangId[8] = L"\0";
//
// Data collection thread variables
//
#define COLLECTION_WAIT_TIME 10000L // 10 seconds to get all the data
HANDLE hCollectThread = NULL;
#define COLLECT_THREAD_PROCESS_EVENT 0
#define COLLECT_THREAD_EXIT_EVENT 1
#define COLLECT_THREAD_LOOP_EVENT_COUNT 2
#define COLLECT_THREAD_DONE_EVENT 2
#define COLLECT_THREAD_EVENT_COUNT 3
static HANDLE hCollectEvents[COLLECT_THREAD_EVENT_COUNT];
static BOOL bThreadHung = FALSE;
static DWORD CollectThreadFunction (LPVOID dwArg);
#define COLL_FLAG_USE_SEPARATE_THREAD 1
DWORD dwCollectionFlags = 0;
//
// Global variable Definitions
//
// event log handle for perflib generated errors
//
HANDLE hEventLog = NULL;
//
// used to count concurrent opens.
//
DWORD NumberOfOpens = 0;
//
// Synchronization objects for Multi-threaded access
//
HANDLE hGlobalDataMutex = NULL; // sync for ctr object list
//
// computer name cache buffers. Initialized in predefh.c
//
DWORD ComputerNameLength;
LPWSTR pComputerName = NULL;
// The next pointer is used to point to an array of addresses of
// Open/Collect/Close routines found by searching the Configuration Registry.
// object list head
PEXT_OBJECT ExtensibleObjects = NULL;
//
// count of active list users (threads)
DWORD dwExtObjListRefCount = 0;
//
// event to indicate the object list is not in use
HANDLE hExtObjListIsNotInUse = NULL;
//
// Number of Extensible Objects found during the "open" call
DWORD NumExtensibleObjects = 0;
//
// see if the perflib data is restricted to ADMIN's ONLY or just anyone
//
static LONG lCheckProfileSystemRight = CPSR_NOT_DEFINED;
//
// flag to see if the ProfileSystemPerformance priv should be set.
// if it is attempted and the caller does not have permission to use this priv.
// it won't be set. This is only attempted once.
//
static BOOL bEnableProfileSystemPerfPriv = FALSE;
//
// timeout value (in mS) for timing threads & libraries
//
DWORD dwThreadAndLibraryTimeout = PERFLIB_TIMING_THREAD_TIMEOUT;
// global key for access to HKLM\Software\....\Perflib
//
HKEY ghKeyPerflib = NULL;
//
// Error report frequency
DWORD dwErrorFrequency = 1;
LONG lEventLogLevel = LOG_NONE;
LONG lPerflibConfigFlags = PLCF_DEFAULT;
// performance data block entries
WCHAR szPerflibSectionFile[MAX_PATH];
WCHAR szPerflibSectionName[MAX_PATH];
HANDLE hPerflibSectionFile = NULL;
HANDLE hPerflibSectionMap = NULL;
LPVOID lpPerflibSectionAddr = NULL;
DWORD dwBoostPriority = 1;
#define dwPerflibSectionMaxEntries 127L
const DWORD dwPerflibSectionSize = (sizeof(PERFDATA_SECTION_HEADER) + \
(sizeof(PERFDATA_SECTION_RECORD) * dwPerflibSectionMaxEntries));
// forward function references
LONG
PerfEnumTextValue (
IN HKEY hKey,
IN DWORD dwIndex,
OUT PUNICODE_STRING lpValueName,
OUT LPDWORD lpReserved OPTIONAL,
OUT LPDWORD lpType OPTIONAL,
OUT LPBYTE lpData,
IN OUT LPDWORD lpcbData,
OUT LPDWORD lpcbLen OPTIONAL
);
#if 0 // collection thread functions are not supported
DWORD
OpenCollectionThread (
)
{
BOOL bError = FALSE;
DWORD dwThreadID;
assert (hCollectThread == NULL);
// if it's already created, then just return
if (hCollectThread != NULL) return ERROR_SUCCESS;
bThreadHung = FALSE;
hCollectEvents[COLLECT_THREAD_PROCESS_EVENT] = CreateEvent (
NULL, // default security
FALSE, // auto reset
FALSE, // non-signaled
NULL); // no name
bError = hCollectEvents[COLLECT_THREAD_PROCESS_EVENT] == NULL;
assert (hCollectEvents[COLLECT_THREAD_PROCESS_EVENT] != NULL);
hCollectEvents[COLLECT_THREAD_EXIT_EVENT] = CreateEvent (
NULL, // default security
FALSE, // auto reset
FALSE, // non-signaled
NULL); // no name
bError = (hCollectEvents[COLLECT_THREAD_EXIT_EVENT] == NULL) | bError;
assert (hCollectEvents[COLLECT_THREAD_EXIT_EVENT] != NULL);
hCollectEvents[COLLECT_THREAD_DONE_EVENT] = CreateEvent (
NULL, // default security
FALSE, // auto reset
FALSE, // non-signaled
NULL); // no name
bError = (hCollectEvents[COLLECT_THREAD_DONE_EVENT] == NULL) | bError;
assert (hCollectEvents[COLLECT_THREAD_DONE_EVENT] != NULL);
if (!bError) {
// create data collection thread
hCollectThread = CreateThread (
NULL, // default security
0, // default stack size
(LPTHREAD_START_ROUTINE)CollectThreadFunction,
NULL, // no argument
0, // no flags
&dwThreadID); // we don't need the ID so it's in an automatic variable
if (hCollectThread == NULL) {
bError = TRUE;
}
assert (hCollectThread != NULL);
}
if (bError) {
if (hCollectEvents[COLLECT_THREAD_PROCESS_EVENT] != NULL) {
CloseHandle (hCollectEvents[COLLECT_THREAD_PROCESS_EVENT]);
hCollectEvents[COLLECT_THREAD_PROCESS_EVENT] = NULL;
}
if (hCollectEvents[COLLECT_THREAD_EXIT_EVENT] != NULL) {
CloseHandle (hCollectEvents[COLLECT_THREAD_EXIT_EVENT]);
hCollectEvents[COLLECT_THREAD_EXIT_EVENT] = NULL;
}
if (hCollectEvents[COLLECT_THREAD_DONE_EVENT] != NULL) {
CloseHandle (hCollectEvents[COLLECT_THREAD_DONE_EVENT] = NULL);
hCollectEvents[COLLECT_THREAD_DONE_EVENT] = NULL;
}
if (hCollectThread != NULL) {
CloseHandle (hCollectThread);
hCollectThread = NULL;
}
return (GetLastError());
} else {
return ERROR_SUCCESS;
}
}
DWORD
CloseCollectionThread (
)
{
if (hCollectThread != NULL) {
// close the data collection thread
if (bThreadHung) {
// then kill it the hard way
// this might cause problems, but it's better than
// a thread leak
TerminateThread (hCollectThread, ERROR_TIMEOUT);
} else {
// then ask it to leave
SetEvent (hCollectEvents[COLLECT_THREAD_EXIT_EVENT]);
}
// wait for thread to leave
WaitForSingleObject (hCollectThread, COLLECTION_WAIT_TIME);
// close the handles and clear the variables
CloseHandle (hCollectThread);
hCollectThread = NULL;
CloseHandle (hCollectEvents[COLLECT_THREAD_PROCESS_EVENT]);
hCollectEvents[COLLECT_THREAD_PROCESS_EVENT] = NULL;
CloseHandle (hCollectEvents[COLLECT_THREAD_EXIT_EVENT]);
hCollectEvents[COLLECT_THREAD_EXIT_EVENT] = NULL;
CloseHandle (hCollectEvents[COLLECT_THREAD_DONE_EVENT]);
hCollectEvents[COLLECT_THREAD_DONE_EVENT] = NULL;
} else {
// nothing was opened
}
return ERROR_SUCCESS;
}
#endif
DWORD
PerfOpenKey (
)
{
LARGE_INTEGER liPerfDataWaitTime;
PLARGE_INTEGER pTimeout;
NTSTATUS status = STATUS_SUCCESS;
DWORD dwFnStatus = ERROR_SUCCESS;
DWORD dwType, dwSize, dwValue;
HANDLE hDataMutex;
DWORD bMutexHeld = FALSE;
OSVERSIONINFOEXW OsVersion;
if (hGlobalDataMutex == NULL) {
hDataMutex = CreateMutex(NULL, TRUE, NULL);
if (hDataMutex == NULL) {
DebugPrint((0, "Perf Data Mutex Not Initialized\n"));
goto OPD_Error_Exit_NoSemaphore;
}
if (InterlockedCompareExchangePointer(
&hGlobalDataMutex,
hDataMutex,
NULL) != NULL) {
CloseHandle(hDataMutex); // mutex just got created by another thread
hDataMutex = NULL;
}
else {
hGlobalDataMutex = hDataMutex;
bMutexHeld = TRUE;
}
}
if (!bMutexHeld) {
if ((dwThreadAndLibraryTimeout == 0) ||
(dwThreadAndLibraryTimeout == INFINITE)) {
pTimeout = NULL;
}
else {
liPerfDataWaitTime.QuadPart = MakeTimeOutValue(dwThreadAndLibraryTimeout);
pTimeout = &liPerfDataWaitTime;
}
status = NtWaitForSingleObject (
hGlobalDataMutex, // Mutex
FALSE, // not alertable
pTimeout); // wait time
if (status != STATUS_SUCCESS) {
// unable to contine, return error;
dwFnStatus = PerfpDosError(status);
DebugPrint((0, "Status=%X in waiting for global mutex",
status));
goto OPD_Error_Exit_NoSemaphore;
}
}
// if here, then the data semaphore has been acquired by this thread
if (!NumberOfOpens++) {
if (ghKeyPerflib == NULL) {
dwFnStatus = (DWORD)RegOpenKeyExW (
HKEY_LOCAL_MACHINE,
HKLMPerflibKey,
0L,
KEY_READ,
&ghKeyPerflib);
}
assert (ghKeyPerflib != NULL);
dwSize = sizeof(dwValue);
dwValue = dwType = 0;
dwFnStatus = PrivateRegQueryValueExW (
ghKeyPerflib,
DisablePerformanceCounters,
NULL,
&dwType,
(LPBYTE)&dwValue,
&dwSize);
if ((dwFnStatus == ERROR_SUCCESS) &&
(dwType == REG_DWORD) &&
(dwValue == 1)) {
// then DON'T Load any libraries and unload any that have been
// loaded
NumberOfOpens--; // since it didn't open.
dwFnStatus = ERROR_SERVICE_DISABLED;
} else {
ComputerNameLength = 0;
GetComputerNameW(pComputerName, &ComputerNameLength);
ComputerNameLength++; // account for the NULL terminator
pComputerName = ALLOCMEM(ComputerNameLength * sizeof(WCHAR));
if (pComputerName == NULL) {
ComputerNameLength = 0;
}
else {
if ( !GetComputerNameW(pComputerName, &ComputerNameLength) ) {
//
// Signal failure to data collection routine
//
ComputerNameLength = 0;
} else {
pComputerName[ComputerNameLength] = UNICODE_NULL;
ComputerNameLength = (ComputerNameLength+1) * sizeof(WCHAR);
}
}
WinPerfStartTrace(ghKeyPerflib);
// create event and indicate the list is busy
hExtObjListIsNotInUse = CreateEvent (NULL, TRUE, FALSE, NULL);
// read collection thread flag
dwType = 0;
dwSize = sizeof(DWORD);
dwFnStatus = PrivateRegQueryValueExW (ghKeyPerflib,
cszPerflibFlags,
NULL,
&dwType,
(LPBYTE)&lPerflibConfigFlags,
&dwSize);
if ((dwFnStatus == ERROR_SUCCESS) && (dwType == REG_DWORD)) {
// then keep it
} else {
// apply default value
lPerflibConfigFlags = PLCF_DEFAULT;
}
// create global section for perf data on perflibs
if ((hPerflibSectionFile == NULL) && (lPerflibConfigFlags & PLCF_ENABLE_PERF_SECTION)) {
WCHAR szTmpFileName[MAX_PATH];
PPERFDATA_SECTION_HEADER pHead;
WCHAR szPID[32];
// create section name
lstrcpyW (szPerflibSectionName, (LPCWSTR)L"Perflib_Perfdata_");
_ultow ((ULONG)GetCurrentProcessId(), szPID, 16);
lstrcatW (szPerflibSectionName, szPID);
// create filename
lstrcpyW (szTmpFileName, (LPCWSTR)L"%TEMP%\\");
lstrcatW (szTmpFileName, szPerflibSectionName);
lstrcatW (szTmpFileName, (LPCWSTR)L".dat");
ExpandEnvironmentStrings (szTmpFileName, szPerflibSectionFile, MAX_PATH);
hPerflibSectionFile = CreateFile (szPerflibSectionFile,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
FILE_FLAG_DELETE_ON_CLOSE | FILE_FLAG_RANDOM_ACCESS | FILE_ATTRIBUTE_TEMPORARY,
NULL);
if (hPerflibSectionFile != INVALID_HANDLE_VALUE) {
// create file mapping object
hPerflibSectionMap = CreateFileMapping (
hPerflibSectionFile,
NULL,
PAGE_READWRITE,
0, dwPerflibSectionSize,
szPerflibSectionName);
if (hPerflibSectionMap != NULL) {
// map view of file
lpPerflibSectionAddr = MapViewOfFile (
hPerflibSectionMap,
FILE_MAP_WRITE,
0,0, dwPerflibSectionSize);
if (lpPerflibSectionAddr != NULL) {
// init section if not already
pHead = (PPERFDATA_SECTION_HEADER)lpPerflibSectionAddr;
if (pHead->dwInitSignature != PDSH_INIT_SIG) {
// then init
// clear file to 0
memset (pHead, 0, dwPerflibSectionSize);
pHead->dwEntriesInUse = 0;
pHead->dwMaxEntries = dwPerflibSectionMaxEntries;
pHead->dwMissingEntries = 0;
pHead->dwInitSignature = PDSH_INIT_SIG;
} else {
// already initialized so leave it
}
} else {
// unable to map file so close
TRACE((WINPERF_DBG_TRACE_WARNING),
(&PerflibGuid, __LINE__, PERF_OPEN_KEY, 0, 0, NULL));
CloseHandle (hPerflibSectionMap);
hPerflibSectionMap = NULL;
CloseHandle (hPerflibSectionFile);
hPerflibSectionFile = NULL;
}
} else {
// unable to create file mapping so close file
TRACE((WINPERF_DBG_TRACE_WARNING),
(&PerflibGuid, __LINE__, PERF_OPEN_KEY, 0, 0, NULL));
CloseHandle (hPerflibSectionFile);
hPerflibSectionFile = NULL;
}
} else {
// unable to open file so no perf stats available
TRACE((WINPERF_DBG_TRACE_WARNING),
(&PerflibGuid, __LINE__, PERF_OPEN_KEY, 0, 0, NULL));
hPerflibSectionFile = NULL;
}
}
// find and open perf counters
OpenExtensibleObjects();
dwExtObjListRefCount = 0;
SetEvent (hExtObjListIsNotInUse); // indicate the list is not busy
// read collection thread flag
dwType = 0;
dwSize = sizeof(DWORD);
dwFnStatus = PrivateRegQueryValueExW (ghKeyPerflib,
UseCollectionThread,
NULL,
&dwType,
(LPBYTE)&dwCollectionFlags,
&dwSize);
if ((dwFnStatus == ERROR_SUCCESS) && (dwType == REG_DWORD)) {
// validate the answer
switch (dwCollectionFlags) {
case 0:
// this is a valid value
break;
case COLL_FLAG_USE_SEPARATE_THREAD:
// this feature is not supported so skip through
default:
// this is for invalid values
dwCollectionFlags = 0;
// dwCollectionFlags = COLL_FLAG_USE_SEPARATE_THREAD;
break;
}
}
if (dwFnStatus != ERROR_SUCCESS) {
dwCollectionFlags = 0;
// dwCollectionFlags = COLL_FLAG_USE_SEPARATE_THREAD;
}
if (dwCollectionFlags == COLL_FLAG_USE_SEPARATE_THREAD) {
// create data collection thread
// a seperate thread is required for COM/OLE compatibity as some
// client threads may be COM initialized incorrectly for the
// extensible counter DLL's that may be called
// status = OpenCollectionThread ();
} else {
hCollectEvents[COLLECT_THREAD_PROCESS_EVENT] = NULL;
hCollectEvents[COLLECT_THREAD_EXIT_EVENT] = NULL;
hCollectEvents[COLLECT_THREAD_DONE_EVENT] = NULL;
hCollectThread = NULL;
}
dwFnStatus = ERROR_SUCCESS;
}
RtlZeroMemory(&OsVersion, sizeof(OsVersion));
OsVersion.dwOSVersionInfoSize = sizeof(OsVersion);
status = RtlGetVersion((POSVERSIONINFOW) &OsVersion);
if (NT_SUCCESS(status)) {
if (OsVersion.wProductType == VER_NT_WORKSTATION) {
dwBoostPriority = 0;
}
}
}
// KdPrint(("PERFLIB: [Open] Pid: %d, Number Of PerflibHandles: %d\n",
// GetCurrentProcessId(), NumberOfOpens));
if (hGlobalDataMutex != NULL) ReleaseMutex (hGlobalDataMutex);
OPD_Error_Exit_NoSemaphore:
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_OPEN_KEY, 0, status,
&NumberOfOpens, sizeof(NumberOfOpens), NULL));
return dwFnStatus;
}
LONG
PerfRegQueryValue (
IN HKEY hKey,
IN PUNICODE_STRING lpValueName,
OUT LPDWORD lpReserved OPTIONAL,
OUT LPDWORD lpType OPTIONAL,
OUT LPBYTE lpData,
OUT LPDWORD lpcbData,
OUT LPDWORD lpcbLen OPTIONAL
)
/*++
PerfRegQueryValue - Get data
Inputs:
hKey - Predefined handle to open remote
machine
lpValueName - Name of the value to be returned;
could be "ForeignComputer:<computername>
or perhaps some other objects, separated
by ~; must be Unicode string
lpReserved - should be omitted (NULL)
lpType - should be omitted (NULL)
lpData - pointer to a buffer to receive the
performance data
lpcbData - pointer to a variable containing the
size in bytes of the output buffer;
on output, will receive the number
of bytes actually returned
lpcbLen - Return the number of bytes to transmit to
the client (used by RPC) (optional).
Return Value:
DOS error code indicating status of call or
ERROR_SUCCESS if all ok
--*/
{
DWORD dwQueryType; // type of request
DWORD TotalLen; // Length of the total return block
DWORD Win32Error; // Failure code
DWORD lFnStatus = ERROR_SUCCESS; // Win32 status to return to caller
LPVOID pDataDefinition; // Pointer to next object definition
UNICODE_STRING usLocalValue = {0,0, NULL};
PERF_DATA_BLOCK *pPerfDataBlock = (PERF_DATA_BLOCK *)lpData;
LARGE_INTEGER liQueryWaitTime ;
THREAD_BASIC_INFORMATION tbiData;
LONG lOldPriority, lNewPriority;
NTSTATUS status = STATUS_SUCCESS;
LPWSTR lpLangId = NULL;
DBG_UNREFERENCED_PARAMETER(lpReserved);
HEAP_PROBE();
lOldPriority = lNewPriority = -1;
// make a local copy of the value string if the arg references
// the static buffer since it can be overwritten by
// some of the RegistryEventSource call made by this routine
pDataDefinition = NULL;
if (lpValueName != NULL) {
if (lpValueName == &NtCurrentTeb( )->StaticUnicodeString) {
if (RtlCreateUnicodeString (
&usLocalValue, lpValueName->Buffer)) {
lFnStatus = ERROR_SUCCESS;
} else {
// unable to create string
lFnStatus = ERROR_INVALID_PARAMETER;
}
} else {
// copy the arg to the local structure
memcpy (&usLocalValue, lpValueName, sizeof(UNICODE_STRING));
}
} else {
lFnStatus = ERROR_INVALID_PARAMETER;
goto PRQV_ErrorExit1;
}
if (lFnStatus != ERROR_SUCCESS) {
goto PRQV_ErrorExit1;
}
if (hGlobalDataMutex == NULL) {
// if a Mutex was not allocated then the key needs to be opened.
// Without synchronization, it's too easy for threads to get
// tangled up
lFnStatus = PerfOpenKey ();
if (lFnStatus == ERROR_SUCCESS) {
if (!TestClientForAccess ()) {
if (lEventLogLevel >= LOG_USER) {
LPTSTR szMessageArray[2];
TCHAR szUserName[128];
TCHAR szModuleName[MAX_PATH];
DWORD dwUserNameLength;
dwUserNameLength = sizeof(szUserName)/sizeof(TCHAR);
GetUserName (szUserName, &dwUserNameLength);
GetModuleFileName (NULL, szModuleName,
sizeof(szModuleName)/sizeof(TCHAR));
szMessageArray[0] = szUserName;
szMessageArray[1] = szModuleName;
ReportEvent (hEventLog,
EVENTLOG_ERROR_TYPE, // error type
0, // category (not used)
(DWORD)PERFLIB_ACCESS_DENIED, // event,
NULL, // SID (not used),
2, // number of strings
0, // sizeof raw data
szMessageArray, // message text array
NULL); // raw data
}
lFnStatus = ERROR_ACCESS_DENIED;
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, lFnStatus, NULL));
}
}
}
if (lFnStatus != ERROR_SUCCESS) {
// goto the exit point
goto PRQV_ErrorExit1;
}
if (dwBoostPriority != 0) {
status = NtQueryInformationThread (
NtCurrentThread(),
ThreadBasicInformation,
&tbiData,
sizeof(tbiData),
NULL);
if (NT_SUCCESS(status)) {
lOldPriority = tbiData.Priority;
} else {
TRACE((WINPERF_DBG_TRACE_WARNING),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0,
status, NULL));
lOldPriority = -1;
}
lNewPriority = DEFAULT_THREAD_PRIORITY; // perfmon's favorite priority
//
// Only RAISE the priority here. Don't lower it if it's high
//
if ((lOldPriority > 0) && (lOldPriority < lNewPriority)) {
status = NtSetInformationThread(
NtCurrentThread(),
ThreadPriority,
&lNewPriority,
sizeof(lNewPriority)
);
if (!NT_SUCCESS(status)) {
TRACE((WINPERF_DBG_TRACE_WARNING),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0,
status, NULL));
lOldPriority = -1;
}
} else {
lOldPriority = -1; // to save resetting at the end
}
}
//
// Set the length parameter to zero so that in case of an error,
// nothing will be transmitted back to the client and the client won't
// attempt to unmarshall anything.
//
if( ARGUMENT_PRESENT( lpcbLen )) {
*lpcbLen = 0;
}
// if here, then assume the caller has the necessary access
/*
determine query type, can be one of the following
Global
get all objects
List
get objects in list (usLocalValue)
Foreign Computer
call extensible Counter Routine only
Costly
costly object items
Counter
get counter names for the specified language Id
Help
get help names for the specified language Id
*/
dwQueryType = GetQueryType (usLocalValue.Buffer);
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, dwQueryType, NULL));
if (dwQueryType == QUERY_COUNTER || dwQueryType == QUERY_HELP ||
dwQueryType == QUERY_ADDCOUNTER || dwQueryType == QUERY_ADDHELP ) {
liQueryWaitTime.QuadPart = MakeTimeOutValue(QUERY_WAIT_TIME);
status = NtWaitForSingleObject (
hGlobalDataMutex, // semaphore
FALSE, // not alertable
&liQueryWaitTime); // wait 'til timeout
if (status != STATUS_SUCCESS) {
lFnStatus = ERROR_BUSY;
Win32Error = ERROR_BUSY;
TotalLen = *lpcbData;
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, status, NULL));
} else {
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, status, NULL));
if (hKey == HKEY_PERFORMANCE_DATA) {
lpLangId = NULL;
} else if (hKey == HKEY_PERFORMANCE_TEXT) {
lpLangId = DefaultLangId;
} else if (hKey == HKEY_PERFORMANCE_NLSTEXT) {
RtlZeroMemory(NativeLangId, 8 * sizeof(WCHAR));
lpLangId = &NativeLangId[0];
PerfGetLangId(NativeLangId);
}
status = PerfGetNames (
dwQueryType,
&usLocalValue,
lpData,
lpcbData,
lpcbLen,
lpLangId);
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, status,
&hKey, sizeof(hKey), NULL));
if (!NT_SUCCESS(status) && (hKey == HKEY_PERFORMANCE_NLSTEXT)) {
// Sublanguage doesn't exist, so try the real one
//
TRACE((WINPERF_DBG_TRACE_WARNING),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, status, NULL));
RtlZeroMemory(NativeLangId, 8 * sizeof(WCHAR));
PerfGetPrimaryLangId(GetUserDefaultUILanguage(), NativeLangId);
status = PerfGetNames (
dwQueryType,
&usLocalValue,
lpData,
lpcbData,
lpcbLen,
lpLangId);
}
if (!NT_SUCCESS(status)) {
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, status, NULL));
// convert error to win32 for return
}
lFnStatus = PerfpDosError(status);
if (ARGUMENT_PRESENT (lpType)) {
// test for optional value
*lpType = REG_MULTI_SZ;
}
ReleaseMutex (hGlobalDataMutex);
}
} else {
// define info block for data collection
COLLECT_THREAD_DATA CollectThreadData = {0, NULL, NULL, NULL, NULL, NULL, 0, 0};
liQueryWaitTime.QuadPart = MakeTimeOutValue(QUERY_WAIT_TIME);
status = NtWaitForSingleObject (
hGlobalDataMutex, // semaphore
FALSE, // not alertable
&liQueryWaitTime); // wait 'til timeout
if (status != STATUS_SUCCESS) {
lFnStatus = ERROR_BUSY;
Win32Error = ERROR_BUSY;
TotalLen = *lpcbData;
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, status, NULL));
} else {
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, status, NULL));
//
// Format Return Buffer: start with basic data block
//
TotalLen = sizeof(PERF_DATA_BLOCK) +
((CNLEN+sizeof(UNICODE_NULL))*sizeof(WCHAR));
if ( *lpcbData < TotalLen ) {
Win32Error = ERROR_MORE_DATA;
TRACE((WINPERF_DBG_TRACE_ERROR),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, TotalLen,
lpcbData, sizeof(DWORD), NULL));
} else {
// foreign data provider will return the perf data header
if (dwQueryType == QUERY_FOREIGN) {
// reset the values to avoid confusion
// *lpcbData = 0; // 0 bytes (removed to enable foreign computers)
pDataDefinition = (LPVOID)lpData;
memset (lpData, 0, sizeof (PERF_DATA_BLOCK)); // clear out header
} else {
MonBuildPerfDataBlock(pPerfDataBlock,
(PVOID *) &pDataDefinition,
0,
PROCESSOR_OBJECT_TITLE_INDEX);
}
CollectThreadData.dwQueryType = dwQueryType;
CollectThreadData.lpValueName = usLocalValue.Buffer,
CollectThreadData.lpData = lpData;
CollectThreadData.lpcbData = lpcbData;
CollectThreadData.lppDataDefinition = &pDataDefinition;
CollectThreadData.pCurrentExtObject = NULL;
CollectThreadData.lReturnValue = ERROR_SUCCESS;
CollectThreadData.dwActionFlags = CTD_AF_NO_ACTION;
if (hCollectThread == NULL) {
// then call the function directly and hope for the best
Win32Error = QueryExtensibleData (
&CollectThreadData);
} else {
// collect the data in a separate thread
// load the args
// set event to get things going
SetEvent (hCollectEvents[COLLECT_THREAD_PROCESS_EVENT]);
// now wait for the thread to return
Win32Error = WaitForSingleObject (
hCollectEvents[COLLECT_THREAD_DONE_EVENT],
COLLECTION_WAIT_TIME);
if (Win32Error == WAIT_TIMEOUT) {
bThreadHung = TRUE;
// log error
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, Win32Error, NULL));
if (lEventLogLevel >= LOG_USER) {
LPSTR szMessageArray[2];
WORD wStringIndex;
// load data for eventlog message
wStringIndex = 0;
if (CollectThreadData.pCurrentExtObject != NULL) {
szMessageArray[wStringIndex++] =
CollectThreadData.pCurrentExtObject->szCollectProcName;
} else {
szMessageArray[wStringIndex++] = "Unknown";
}
ReportEventA (hEventLog,
EVENTLOG_ERROR_TYPE, // error type
0, // category (not used)
(DWORD)PERFLIB_COLLECTION_HUNG, // event,
NULL, // SID (not used),
wStringIndex, // number of strings
0, // sizeof raw data
szMessageArray, // message text array
NULL); // raw data
}
DisablePerfLibrary (CollectThreadData.pCurrentExtObject);
// DebugPrint((0, "Collection thread is hung in %s\n",
// CollectThreadData.pCurrentExtObject->szCollectProcName != NULL ?
// CollectThreadData.pCurrentExtObject->szCollectProcName : "Unknown"));
// and then wait forever for the thread to return
// this is done to prevent the function from returning
// while the collection thread is using the buffer
// passed in by the calling function and causing
// all kind of havoc should the buffer be changed and/or
// deleted and then have the thread continue for some reason
Win32Error = WaitForSingleObject (
hCollectEvents[COLLECT_THREAD_DONE_EVENT],
INFINITE);
}
bThreadHung = FALSE; // in case it was true, but came out
// here the thread has returned so continue on
Win32Error = CollectThreadData.lReturnValue;
}
#if 0
if (CollectThreadData.dwActionFlags != CTD_AF_NO_ACTION) {
if (CollectThreadData.dwActionFlags == CTD_AF_OPEN_THREAD) {
OpenCollectionThread();
} else if (CollectThreadData.dwActionFlags == CTD_AF_CLOSE_THREAD) {
CloseCollectionThread();
} else {
assert (CollectThreadData.dwActionFlags != 0);
}
}
#endif
}
ReleaseMutex (hGlobalDataMutex);
}
// if an error was encountered, return it
if (Win32Error != ERROR_SUCCESS) {
lFnStatus = Win32Error;
} else {
//
// Final housekeeping for data return: note data size
//
TotalLen = (DWORD) ((PCHAR) pDataDefinition - (PCHAR) lpData);
*lpcbData = TotalLen;
pPerfDataBlock->TotalByteLength = TotalLen;
lFnStatus = ERROR_SUCCESS;
}
if (ARGUMENT_PRESENT (lpcbLen)) { // test for optional parameter
*lpcbLen = TotalLen;
}
if (ARGUMENT_PRESENT (lpType)) { // test for optional value
*lpType = REG_BINARY;
}
}
PRQV_ErrorExit1:
if (dwBoostPriority != 0) {
// reset thread to original priority
if ((lOldPriority > 0) && (lOldPriority != lNewPriority)) {
NtSetInformationThread(
NtCurrentThread(),
ThreadPriority,
&lOldPriority,
sizeof(lOldPriority)
);
}
}
if (usLocalValue.Buffer != NULL) {
// restore the value string if it was from the local static buffer
// then free the local buffer
if (lpValueName == &NtCurrentTeb( )->StaticUnicodeString) {
memcpy (lpValueName->Buffer, usLocalValue.Buffer, usLocalValue.MaximumLength);
RtlFreeUnicodeString (&usLocalValue);
}
}
HEAP_PROBE();
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_VALUE, 0, lFnStatus, NULL));
return (LONG) lFnStatus;
}
LONG
PerfRegCloseKey
(
IN OUT PHKEY phKey
)
/*++
Routine Description:
Closes all performance handles when the usage count drops to 0.
Arguments:
phKey - Supplies a handle to an open key to be closed.
Return Value:
Returns ERROR_SUCCESS (0) for success; error-code for failure.
--*/
{
NTSTATUS status;
LARGE_INTEGER liQueryWaitTime ;
HANDLE hObjMutex;
LONG lReturn = ERROR_SUCCESS;
HKEY hKey;
PEXT_OBJECT pThisExtObj, pNextExtObj;
//
// Set the handle to NULL so that RPC knows that it has been closed.
//
hKey = *phKey;
*phKey = NULL;
if (hKey != HKEY_PERFORMANCE_DATA) {
return ERROR_SUCCESS;
}
if (NumberOfOpens == 0) {
// KdPrint(("PERFLIB: [Close] Pid: %d, Number Of PerflibHandles: %d\n",
// GetCurrentProcessId(), NumberOfOpens));
return ERROR_SUCCESS;
}
// wait for ext obj list to be "un"-busy
liQueryWaitTime.QuadPart = MakeTimeOutValue (CLOSE_WAIT_TIME);
status = NtWaitForSingleObject (
hExtObjListIsNotInUse,
FALSE,
&liQueryWaitTime);
if (status == STATUS_SUCCESS) {
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_CLOSE_KEY, 0, status, NULL));
// then the list is inactive so continue
if (hGlobalDataMutex != NULL) { // if a mutex was allocated, then use it
// if here, then assume a mutex is ready
liQueryWaitTime.QuadPart = MakeTimeOutValue(CLOSE_WAIT_TIME);
status = NtWaitForSingleObject (
hGlobalDataMutex, // semaphore
FALSE, // not alertable
&liQueryWaitTime); // wait forever
if (status == STATUS_SUCCESS) {
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_CLOSE_KEY, 0, status, NULL));
// now we have a lock on the global data, so continue
NumberOfOpens--;
if (!NumberOfOpens && (hKey == HKEY_PERFORMANCE_DATA)) {
// walk down list of known objects and close and delete each one
pNextExtObj = ExtensibleObjects;
while (pNextExtObj != NULL) {
// close and destroy each entry in the list
pThisExtObj = pNextExtObj;
hObjMutex = pThisExtObj->hMutex;
status = NtWaitForSingleObject (
hObjMutex,
FALSE,
&liQueryWaitTime);
if (status == STATUS_SUCCESS) {
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_CLOSE_KEY, 0, status,
pThisExtObj->szServiceName,
WSTRSIZE(pThisExtObj->szServiceName),
NULL));
InterlockedIncrement((LONG *)&pThisExtObj->dwLockoutCount);
status = CloseExtObjectLibrary(pThisExtObj, TRUE);
// close the handle to the perf subkey
NtClose (pThisExtObj->hPerfKey);
ReleaseMutex (hObjMutex); // release
CloseHandle (hObjMutex); // and free
pNextExtObj = pThisExtObj->pNext;
// toss the memory for this object
FREEMEM (pThisExtObj);
} else {
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_CLOSE_KEY, 0, status,
pThisExtObj->szServiceName,
WSTRSIZE(pThisExtObj->szServiceName),
NULL));
// this shouldn't happen since we've locked the
// list of objects
pNextExtObj = pThisExtObj->pNext;
}
}
// close the global objects
FREEMEM(pComputerName);
ComputerNameLength = 0;
pComputerName = NULL;
ExtensibleObjects = NULL;
NumExtensibleObjects = 0;
// close the timer thread
DestroyPerflibFunctionTimer ();
if (hEventLog != NULL) {
DeregisterEventSource (hEventLog);
hEventLog = NULL;
} // else the event log has already been closed
// release event handle
CloseHandle (hExtObjListIsNotInUse);
hExtObjListIsNotInUse = NULL;
// CloseCollectionThread();
if (ghKeyPerflib != NULL) {
RegCloseKey(ghKeyPerflib);
ghKeyPerflib = NULL;
}
if (lpPerflibSectionAddr != NULL) {
UnmapViewOfFile (lpPerflibSectionAddr);
lpPerflibSectionAddr = NULL;
CloseHandle (hPerflibSectionMap);
hPerflibSectionMap = NULL;
CloseHandle (hPerflibSectionFile);
hPerflibSectionFile = NULL;
}
ReleaseMutex(hGlobalDataMutex);
} else { // this isn't the last open call so return success
assert(NumberOfOpens != 0);
ReleaseMutex (hGlobalDataMutex);
}
} else {
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_CLOSE_KEY, 0, status, NULL));
// unable to lock the global data mutex in a timely fashion
// so return
lReturn = ERROR_BUSY;
}
} else {
// if there's no mutex then something's fishy. It probably hasn't
// been opened, yet.
lReturn = ERROR_NOT_READY;
}
} else {
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_CLOSE_KEY, 0, status, NULL));
// the object list is still in use so return and let the
// caller try again later
lReturn = WAIT_TIMEOUT;
}
// KdPrint(("PERFLIB: [Close] Pid: %d, Number Of PerflibHandles: %d\n",
// GetCurrentProcessId(), NumberOfOpens));
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_CLOSE_KEY, 0, lReturn,
&NumberOfOpens, sizeof(NumberOfOpens), NULL));
return lReturn;
}
LONG
PerfRegSetValue (
IN HKEY hKey,
IN LPWSTR lpValueName,
IN DWORD Reserved,
IN DWORD dwType,
IN LPBYTE lpData,
IN DWORD cbData
)
/*++
PerfRegSetValue - Set data
Inputs:
hKey - Predefined handle to open remote
machine
lpValueName - Name of the value to be returned;
could be "ForeignComputer:<computername>
or perhaps some other objects, separated
by ~; must be Unicode string
lpReserved - should be omitted (NULL)
lpType - should be REG_MULTI_SZ
lpData - pointer to a buffer containing the
performance name
lpcbData - pointer to a variable containing the
size in bytes of the input buffer;
Return Value:
DOS error code indicating status of call or
ERROR_SUCCESS if all ok
--*/
{
DWORD dwQueryType; // type of request
LPWSTR lpLangId = NULL;
NTSTATUS status;
UNICODE_STRING String;
LONG lReturn = ERROR_SUCCESS;
UNREFERENCED_PARAMETER(dwType);
UNREFERENCED_PARAMETER(Reserved);
dwQueryType = GetQueryType (lpValueName);
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_SET_VALUE, 0, dwQueryType,
&hKey, sizeof(hKey), NULL));
// convert the query to set commands
if ((dwQueryType == QUERY_COUNTER) ||
(dwQueryType == QUERY_ADDCOUNTER)) {
dwQueryType = QUERY_ADDCOUNTER;
} else if ((dwQueryType == QUERY_HELP) ||
(dwQueryType == QUERY_ADDHELP)) {
dwQueryType = QUERY_ADDHELP;
} else {
lReturn = ERROR_BADKEY;
goto Error_exit;
}
if (hKey == HKEY_PERFORMANCE_TEXT) {
lpLangId = DefaultLangId;
} else if (hKey == HKEY_PERFORMANCE_NLSTEXT) {
lpLangId = &NativeLangId[0];
PerfGetLangId(NativeLangId);
} else {
lReturn = ERROR_BADKEY;
goto Error_exit;
}
RtlInitUnicodeString(&String, lpValueName);
status = PerfGetNames (
dwQueryType,
&String,
lpData,
&cbData,
NULL,
lpLangId);
if (!NT_SUCCESS(status) && (hKey == HKEY_PERFORMANCE_NLSTEXT)) {
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_SET_VALUE, 0, status, NULL));
// Sublanguage doesn't exist, so try the real one
//
PerfGetPrimaryLangId(GetUserDefaultUILanguage(), NativeLangId);
status = PerfGetNames (
dwQueryType,
&String,
lpData,
&cbData,
NULL,
lpLangId);
}
if (!NT_SUCCESS(status)) {
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_SET_VALUE, 0, status, NULL));
lReturn = (error_status_t)PerfpDosError(status);
}
Error_exit:
TRACE((WINPERF_DBG_TRACE_INFO),
(&PerflibGuid, __LINE__, PERF_REG_SET_VALUE, 0, lReturn, NULL));
return (lReturn);
}
LONG
PerfRegEnumKey (
IN HKEY hKey,
IN DWORD dwIndex,
OUT PUNICODE_STRING lpName,
OUT LPDWORD lpReserved OPTIONAL,
OUT PUNICODE_STRING lpClass OPTIONAL,
OUT PFILETIME lpftLastWriteTime OPTIONAL
)
/*++
Routine Description:
Enumerates keys under HKEY_PERFORMANCE_DATA.
Arguments:
Same as RegEnumKeyEx. Returns that there are no such keys.
Return Value:
Returns ERROR_SUCCESS (0) for success; error-code for failure.
--*/
{
UNREFERENCED_PARAMETER(hKey);
UNREFERENCED_PARAMETER(dwIndex);
UNREFERENCED_PARAMETER(lpReserved);
lpName->Length = 0;
if (ARGUMENT_PRESENT (lpClass)) {
lpClass->Length = 0;
}
if ( ARGUMENT_PRESENT(lpftLastWriteTime) ) {
lpftLastWriteTime->dwLowDateTime = 0;
lpftLastWriteTime->dwHighDateTime = 0;
}
return ERROR_NO_MORE_ITEMS;
}
LONG
PerfRegQueryInfoKey (
IN HKEY hKey,
OUT PUNICODE_STRING lpClass,
OUT LPDWORD lpReserved OPTIONAL,
OUT LPDWORD lpcSubKeys,
OUT LPDWORD lpcbMaxSubKeyLen,
OUT LPDWORD lpcbMaxClassLen,
OUT LPDWORD lpcValues,
OUT LPDWORD lpcbMaxValueNameLen,
OUT LPDWORD lpcbMaxValueLen,
OUT LPDWORD lpcbSecurityDescriptor,
OUT PFILETIME lpftLastWriteTime
)
/*++
Routine Description:
This returns information concerning the predefined handle
HKEY_PERFORMANCE_DATA
Arguments:
Same as RegQueryInfoKey.
Return Value:
Returns ERROR_SUCCESS (0) for success.
--*/
{
DWORD TempLength=0;
DWORD MaxValueLen=0;
UNICODE_STRING Null;
SECURITY_DESCRIPTOR SecurityDescriptor;
HKEY hPerflibKey;
OBJECT_ATTRIBUTES Obja;
NTSTATUS Status;
DWORD PerfStatus = ERROR_SUCCESS;
UNICODE_STRING PerflibSubKeyString;
BOOL bGetSACL = TRUE;
UNREFERENCED_PARAMETER(lpReserved);
if (lpClass->MaximumLength >= sizeof(UNICODE_NULL)) {
lpClass->Length = 0;
*lpClass->Buffer = UNICODE_NULL;
}
*lpcSubKeys = 0;
*lpcbMaxSubKeyLen = 0;
*lpcbMaxClassLen = 0;
*lpcValues = NUM_VALUES;
*lpcbMaxValueNameLen = VALUE_NAME_LENGTH;
*lpcbMaxValueLen = 0;
if ( ARGUMENT_PRESENT(lpftLastWriteTime) ) {
lpftLastWriteTime->dwLowDateTime = 0;
lpftLastWriteTime->dwHighDateTime = 0;
}
if ((hKey == HKEY_PERFORMANCE_TEXT) ||
(hKey == HKEY_PERFORMANCE_NLSTEXT)) {
//
// We have to go enumerate the values to determine the answer for
// the MaxValueLen parameter.
//
Null.Buffer = NULL;
Null.Length = 0;
Null.MaximumLength = 0;
PerfStatus = PerfEnumTextValue(hKey,
0,
&Null,
NULL,
NULL,
NULL,
&MaxValueLen,
NULL);
if (PerfStatus == ERROR_SUCCESS) {
PerfStatus = PerfEnumTextValue(hKey,
1,
&Null,
NULL,
NULL,
NULL,
&TempLength,
NULL);
}
if (PerfStatus == ERROR_SUCCESS) {
if (TempLength > MaxValueLen) {
MaxValueLen = TempLength;
}
*lpcbMaxValueLen = MaxValueLen;
} else {
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_INFO_KEY, 0, PerfStatus, NULL));
// unable to successfully enum text values for this
// key so return 0's and the error code
*lpcValues = 0;
*lpcbMaxValueNameLen = 0;
}
}
if (PerfStatus == ERROR_SUCCESS) {
// continune if all is OK
// now get the size of SecurityDescriptor for Perflib key
RtlInitUnicodeString (
&PerflibSubKeyString,
PerflibKey);
//
// Initialize the OBJECT_ATTRIBUTES structure and open the key.
//
InitializeObjectAttributes(
&Obja,
&PerflibSubKeyString,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenKey(
&hPerflibKey,
MAXIMUM_ALLOWED | ACCESS_SYSTEM_SECURITY,
&Obja
);
if ( ! NT_SUCCESS( Status )) {
Status = NtOpenKey(
&hPerflibKey,
MAXIMUM_ALLOWED,
&Obja
);
bGetSACL = FALSE;
}
if ( ! NT_SUCCESS( Status )) {
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_INFO_KEY, 0, Status, NULL));
} else {
*lpcbSecurityDescriptor = 0;
if (bGetSACL == FALSE) {
//
// Get the size of the key's SECURITY_DESCRIPTOR for OWNER, GROUP
// and DACL. These three are always accessible (or inaccesible)
// as a set.
//
Status = NtQuerySecurityObject(
hPerflibKey,
OWNER_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
| DACL_SECURITY_INFORMATION,
&SecurityDescriptor,
0,
lpcbSecurityDescriptor
);
} else {
//
// Get the size of the key's SECURITY_DESCRIPTOR for OWNER, GROUP,
// DACL, and SACL.
//
Status = NtQuerySecurityObject(
hPerflibKey,
OWNER_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
| DACL_SECURITY_INFORMATION
| SACL_SECURITY_INFORMATION,
&SecurityDescriptor,
0,
lpcbSecurityDescriptor
);
}
if( Status != STATUS_BUFFER_TOO_SMALL ) {
*lpcbSecurityDescriptor = 0;
} else {
// this is expected so set status to success
Status = STATUS_SUCCESS;
}
NtClose(hPerflibKey);
}
if (NT_SUCCESS( Status )) {
PerfStatus = ERROR_SUCCESS;
} else {
TRACE((WINPERF_DBG_TRACE_FATAL),
(&PerflibGuid, __LINE__, PERF_REG_QUERY_INFO_KEY, 0, Status, NULL));
// return error
PerfStatus = PerfpDosError(Status);
}
} // else return status
return (LONG) PerfStatus;
}
LONG
PerfRegEnumValue (
IN HKEY hKey,
IN DWORD dwIndex,
OUT PUNICODE_STRING lpValueName,
OUT LPDWORD lpReserved OPTIONAL,
OUT LPDWORD lpType OPTIONAL,
OUT LPBYTE lpData,
IN OUT LPDWORD lpcbData,
OUT LPDWORD lpcbLen OPTIONAL
)
/*++
Routine Description:
Enumerates Values under HKEY_PERFORMANCE_DATA.
Arguments:
Same as RegEnumValue. Returns the values.
Return Value:
Returns ERROR_SUCCESS (0) for success; error-code for failure.
--*/
{
USHORT cbNameSize;
// table of names used by enum values
UNICODE_STRING ValueNames[NUM_VALUES];
ValueNames [0].Length = (WORD)(lstrlenW (GLOBAL_STRING) * sizeof(WCHAR));
ValueNames [0].MaximumLength = (WORD)(ValueNames [0].Length + sizeof(UNICODE_NULL));
ValueNames [0].Buffer = (LPWSTR)GLOBAL_STRING;
ValueNames [1].Length = (WORD)(lstrlenW(COSTLY_STRING) * sizeof(WCHAR));
ValueNames [1].MaximumLength = (WORD)(ValueNames [1].Length + sizeof(UNICODE_NULL));
ValueNames [1].Buffer = (LPWSTR)COSTLY_STRING;
if ((hKey == HKEY_PERFORMANCE_TEXT) ||
(hKey == HKEY_PERFORMANCE_NLSTEXT)) {
return(PerfEnumTextValue(hKey,
dwIndex,
lpValueName,
lpReserved,
lpType,
lpData,
lpcbData,
lpcbLen));
}
if ( dwIndex >= NUM_VALUES ) {
//
// This is a request for data from a non-existent value name
//
*lpcbData = 0;
return ERROR_NO_MORE_ITEMS;
}
cbNameSize = ValueNames[dwIndex].Length;
if ( lpValueName->MaximumLength < cbNameSize ) {
return ERROR_MORE_DATA;
} else {
lpValueName->Length = cbNameSize;
RtlCopyUnicodeString(lpValueName, &ValueNames[dwIndex]);
if (ARGUMENT_PRESENT (lpType)) {
*lpType = REG_BINARY;
}
return PerfRegQueryValue(hKey,
lpValueName,
NULL,
lpType,
lpData,
lpcbData,
lpcbLen);
}
}
LONG
PerfEnumTextValue (
IN HKEY hKey,
IN DWORD dwIndex,
OUT PUNICODE_STRING lpValueName,
OUT LPDWORD lpReserved OPTIONAL,
OUT LPDWORD lpType OPTIONAL,
OUT LPBYTE lpData,
IN OUT LPDWORD lpcbData,
OUT LPDWORD lpcbLen OPTIONAL
)
/*++
Routine Description:
Enumerates Values under Perflib\lang
Arguments:
Same as RegEnumValue. Returns the values.
Return Value:
Returns ERROR_SUCCESS (0) for success; error-code for failure.
--*/
{
UNICODE_STRING FullValueName;
LONG lReturn = ERROR_SUCCESS;
//
// Only two values, "Counter" and "Help"
//
if (dwIndex==0) {
lpValueName->Length = 0;
RtlInitUnicodeString(&FullValueName, CounterValue);
} else if (dwIndex==1) {
lpValueName->Length = 0;
RtlInitUnicodeString(&FullValueName, HelpValue);
} else {
return(ERROR_NO_MORE_ITEMS);
}
RtlCopyUnicodeString(lpValueName, &FullValueName);
//
// We need to NULL terminate the name to make RPC happy.
//
if (lpValueName->Length+sizeof(WCHAR) <= lpValueName->MaximumLength) {
lpValueName->Buffer[lpValueName->Length / sizeof(WCHAR)] = UNICODE_NULL;
lpValueName->Length += sizeof(UNICODE_NULL);
}
lReturn = PerfRegQueryValue(hKey,
&FullValueName,
lpReserved,
lpType,
lpData,
lpcbData,
lpcbLen);
return lReturn;
}
#if 0
DWORD
CollectThreadFunction (
LPDWORD dwArg
)
{
DWORD dwWaitStatus = 0;
BOOL bExit = FALSE;
NTSTATUS status = STATUS_SUCCESS;
THREAD_BASIC_INFORMATION tbiData;
LONG lOldPriority, lNewPriority;
LONG lStatus;
UNREFERENCED_PARAMETER (dwArg);
// KdPrint(("PERFLIB: Entering Data Collection Thread: PID: %d, TID: %d\n",
// GetCurrentProcessId(), GetCurrentThreadId()));
// raise the priority of this thread
status = NtQueryInformationThread (
NtCurrentThread(),
ThreadBasicInformation,
&tbiData,
sizeof(tbiData),
NULL);
if (NT_SUCCESS(status)) {
lOldPriority = tbiData.Priority;
lNewPriority = DEFAULT_THREAD_PRIORITY; // perfmon's favorite priority
//
// Only RAISE the priority here. Don't lower it if it's high
//
if (lOldPriority < lNewPriority) {
status = NtSetInformationThread(
NtCurrentThread(),
ThreadPriority,
&lNewPriority,
sizeof(lNewPriority)
);
if (status != STATUS_SUCCESS) {
DebugPrint((0, "Set Thread Priority failed: 0x%8.8x\n", status));
}
}
}
// wait for flags
while (!bExit) {
dwWaitStatus = WaitForMultipleObjects (
COLLECT_THREAD_LOOP_EVENT_COUNT,
hCollectEvents,
FALSE, // wait for ANY event to go
INFINITE); // wait for ever
// see why the wait returned:
if (dwWaitStatus == (WAIT_OBJECT_0 + COLLECT_THREAD_PROCESS_EVENT)) {
// the event is cleared automatically
// collect data
lStatus = QueryExtensibleData (
&CollectThreadData);
CollectThreadData.lReturnValue = lStatus;
SetEvent (hCollectEvents[COLLECT_THREAD_DONE_EVENT]);
} else if (dwWaitStatus == (WAIT_OBJECT_0 + COLLECT_THREAD_EXIT_EVENT)) {
bExit = TRUE;
continue; // go up and bail out
} else {
// who knows, so output message
KdPrint(("\nPERFLILB: Collect Thread wait returned unknown value: 0x%8.8x",dwWaitStatus));
bExit = TRUE;
continue;
}
}
// KdPrint(("PERFLIB: Leaving Data Collection Thread: PID: %d, TID: %d\n",
// GetCurrentProcessId(), GetCurrentThreadId()));
return ERROR_SUCCESS;
}
#endif
BOOL
PerfRegCleanup()
/*++
Routine Description:
Cleans up anything that perflib uses before it unloads. Assumes
that there are queries or perf reg opens outstanding.
Arguments:
None
Return Value:
Returns TRUE if succeed. FALSE otherwise.
--*/
{
if (hGlobalDataMutex != NULL) {
if (NumberOfOpens != 0)
return FALSE;
CloseHandle(hGlobalDataMutex);
hGlobalDataMutex = NULL;
}
return TRUE;
}
Reference in a new issue Copy permalink