ReactOS 0.4.15-dev-7659-ga55345b
pdh_main.c File Reference
#include <stdarg.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "pdh.h"
#include "pdhmsg.h"
#include "winperf.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/list.h"
Include dependency graph for pdh_main.c:

Go to the source code of this file.

Classes

union  value
 
struct  counter
 
struct  query
 
struct  source
 

Macros

#define NONAMELESSUNION
 
#define PDH_MAGIC_COUNTER   0x50444831 /* 'PDH1' */
 
#define PDH_MAGIC_QUERY   0x50444830 /* 'PDH0' */
 
#define TYPE_PROCESSOR_TIME
 
#define TYPE_UPTIME    (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (pdh)
 
static WCHARpdh_strdup (const WCHAR *src)
 
static WCHARpdh_strdup_aw (const char *src)
 
BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 
static struct countercreate_counter (void)
 
static void destroy_counter (struct counter *counter)
 
static struct querycreate_query (void)
 
static void destroy_query (struct query *query)
 
static void CALLBACK collect_processor_time (struct counter *counter)
 
static void CALLBACK collect_uptime (struct counter *counter)
 
static BOOL is_local_machine (const WCHAR *name, DWORD len)
 
static BOOL pdh_match_path (LPCWSTR fullpath, LPCWSTR path)
 
PDH_STATUS WINAPI PdhAddCounterA (PDH_HQUERY query, LPCSTR path, DWORD_PTR userdata, PDH_HCOUNTER *counter)
 
PDH_STATUS WINAPI PdhAddCounterW (PDH_HQUERY hquery, LPCWSTR path, DWORD_PTR userdata, PDH_HCOUNTER *hcounter)
 
PDH_STATUS WINAPI PdhAddEnglishCounterA (PDH_HQUERY query, LPCSTR path, DWORD_PTR userdata, PDH_HCOUNTER *counter)
 
PDH_STATUS WINAPI PdhAddEnglishCounterW (PDH_HQUERY query, LPCWSTR path, DWORD_PTR userdata, PDH_HCOUNTER *counter)
 
static PDH_STATUS format_value (struct counter *counter, DWORD format, union value *raw1, union value *raw2, PDH_FMT_COUNTERVALUE *value)
 
PDH_STATUS WINAPI PdhCalculateCounterFromRawValue (PDH_HCOUNTER handle, DWORD format, PPDH_RAW_COUNTER raw1, PPDH_RAW_COUNTER raw2, PPDH_FMT_COUNTERVALUE value)
 
PDH_STATUS WINAPI PdhCloseQuery (PDH_HQUERY handle)
 
static void collect_query_data (struct query *query)
 
PDH_STATUS WINAPI PdhCollectQueryData (PDH_HQUERY handle)
 
static DWORD CALLBACK collect_query_thread (void *arg)
 
PDH_STATUS WINAPI PdhCollectQueryDataEx (PDH_HQUERY handle, DWORD interval, HANDLE event)
 
PDH_STATUS WINAPI PdhCollectQueryDataWithTime (PDH_HQUERY handle, LONGLONG *timestamp)
 
PDH_STATUS WINAPI PdhExpandWildCardPathA (LPCSTR szDataSource, LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags)
 
PDH_STATUS WINAPI PdhExpandWildCardPathW (LPCWSTR szDataSource, LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags)
 
PDH_STATUS WINAPI PdhExpandCounterPathA (LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength)
 
PDH_STATUS WINAPI PdhExpandCounterPathW (LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength)
 
PDH_STATUS WINAPI PdhGetCounterInfoA (PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_A info)
 
PDH_STATUS WINAPI PdhGetCounterInfoW (PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_W info)
 
PDH_STATUS WINAPI PdhGetCounterTimeBase (PDH_HCOUNTER handle, LONGLONG *base)
 
PDH_STATUS WINAPI PdhGetDllVersion (LPDWORD version)
 
PDH_STATUS WINAPI PdhGetFormattedCounterValue (PDH_HCOUNTER handle, DWORD format, LPDWORD type, PPDH_FMT_COUNTERVALUE value)
 
PDH_STATUS WINAPI PdhGetRawCounterValue (PDH_HCOUNTER handle, LPDWORD type, PPDH_RAW_COUNTER value)
 
PDH_STATUS WINAPI PdhLookupPerfIndexByNameA (LPCSTR machine, LPCSTR name, LPDWORD index)
 
PDH_STATUS WINAPI PdhLookupPerfIndexByNameW (LPCWSTR machine, LPCWSTR name, LPDWORD index)
 
PDH_STATUS WINAPI PdhLookupPerfNameByIndexA (LPCSTR machine, DWORD index, LPSTR buffer, LPDWORD size)
 
PDH_STATUS WINAPI PdhLookupPerfNameByIndexW (LPCWSTR machine, DWORD index, LPWSTR buffer, LPDWORD size)
 
PDH_STATUS WINAPI PdhOpenQueryA (LPCSTR source, DWORD_PTR userdata, PDH_HQUERY *query)
 
PDH_STATUS WINAPI PdhOpenQueryW (LPCWSTR source, DWORD_PTR userdata, PDH_HQUERY *handle)
 
PDH_STATUS WINAPI PdhRemoveCounter (PDH_HCOUNTER handle)
 
PDH_STATUS WINAPI PdhSetCounterScaleFactor (PDH_HCOUNTER handle, LONG factor)
 
PDH_STATUS WINAPI PdhValidatePathA (LPCSTR path)
 
static PDH_STATUS validate_path (LPCWSTR path)
 
PDH_STATUS WINAPI PdhValidatePathW (LPCWSTR path)
 
PDH_STATUS WINAPI PdhVbAddCounter (PDH_HQUERY query, LPCSTR path, PDH_HCOUNTER *counter)
 
PDH_STATUS WINAPI PdhValidatePathExA (PDH_HLOG source, LPCSTR path)
 
PDH_STATUS WINAPI PdhValidatePathExW (PDH_HLOG source, LPCWSTR path)
 
PDH_STATUS WINAPI PdhMakeCounterPathA (PDH_COUNTER_PATH_ELEMENTS_A *e, LPSTR buffer, LPDWORD buflen, DWORD flags)
 
PDH_STATUS WINAPI PdhMakeCounterPathW (PDH_COUNTER_PATH_ELEMENTS_W *e, LPWSTR buffer, LPDWORD buflen, DWORD flags)
 
PDH_STATUS WINAPI PdhEnumObjectItemsA (LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName, LPSTR mszCounterList, LPDWORD pcchCounterListLength, LPSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
 
PDH_STATUS WINAPI PdhEnumObjectItemsW (LPCWSTR szDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName, LPWSTR mszCounterList, LPDWORD pcchCounterListLength, LPWSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
 
PDH_STATUS WINAPI PdhSetDefaultRealTimeDataSource (DWORD source)
 
PDH_STATUS WINAPI PdhGetLogFileTypeA (const char *log, DWORD *type)
 
PDH_STATUS WINAPI PdhGetLogFileTypeW (const WCHAR *log, DWORD *type)
 
PDH_STATUS WINAPI PdhBindInputDataSourceA (PDH_HLOG *source, const char *filenamelist)
 
PDH_STATUS WINAPI PdhBindInputDataSourceW (PDH_HLOG *source, const WCHAR *filenamelist)
 

Variables

static CRITICAL_SECTION pdh_handle_cs = { &pdh_handle_cs_debug, -1, 0, 0, 0, 0 }
 
static CRITICAL_SECTION_DEBUG pdh_handle_cs_debug
 
static const WCHAR path_processor_time []
 
static const WCHAR path_processor []
 
static const WCHAR path_uptime []
 
static const struct source counter_sources []
 

Macro Definition Documentation

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 25 of file pdh_main.c.

◆ PDH_MAGIC_COUNTER

#define PDH_MAGIC_COUNTER   0x50444831 /* 'PDH1' */

Definition at line 118 of file pdh_main.c.

◆ PDH_MAGIC_QUERY

#define PDH_MAGIC_QUERY   0x50444830 /* 'PDH0' */

Definition at line 139 of file pdh_main.c.

◆ TYPE_PROCESSOR_TIME

#define TYPE_PROCESSOR_TIME
Value:
#define PERF_DELTA_COUNTER
Definition: winperf.h:37
#define PERF_SIZE_LARGE
Definition: winperf.h:15
#define PERF_TIMER_100NS
Definition: winperf.h:35
#define PERF_COUNTER_RATE
Definition: winperf.h:26
#define PERF_TYPE_COUNTER
Definition: winperf.h:19
#define PERF_DISPLAY_PERCENT
Definition: winperf.h:43
#define PERF_INVERSE_COUNTER
Definition: winperf.h:39

Definition at line 201 of file pdh_main.c.

◆ TYPE_UPTIME

Function Documentation

◆ collect_processor_time()

static void CALLBACK collect_processor_time ( struct counter counter)
static

Definition at line 189 of file pdh_main.c.

190{
191 counter->two.largevalue = 500000; /* FIXME */
193}
#define PDH_CSTATUS_VALID_DATA
Definition: pdhmsg.h:24
DWORD status
Definition: pdh_main.c:106
union value two
Definition: pdh_main.c:115
LONGLONG largevalue
Definition: pdh_main.c:97

◆ collect_query_data()

static void collect_query_data ( struct query query)
static

Definition at line 445 of file pdh_main.c.

446{
447 struct list *item;
448
450 {
452 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
453
454 counter->collect( counter );
455
456 GetLocalTime( &time );
458 }
459}
Definition: list.h:37
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:158
VOID WINAPI GetLocalTime(OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:286
uint32_t entry
Definition: isohybrid.c:63
__u16 time
Definition: mkdosfs.c:8
static ATOM item
Definition: dde.c:856
#define LIST_FOR_EACH(cursor, list)
Definition: list.h:188
FILETIME stamp
Definition: pdh_main.c:112
struct list counters
Definition: pdh_main.c:149
#define LIST_ENTRY(type)
Definition: queue.h:175

Referenced by collect_query_thread(), PdhCollectQueryData(), and PdhCollectQueryDataWithTime().

◆ collect_query_thread()

static DWORD CALLBACK collect_query_thread ( void arg)
static

Definition at line 489 of file pdh_main.c.

490{
491 struct query *query = arg;
494
495 for (;;)
496 {
498
501 {
504 }
505
507
508 if (!SetEvent( query->wait ))
509 {
511 ExitThread( 0 );
512 }
514 }
515}
#define WAIT_TIMEOUT
Definition: dderror.h:14
VOID WINAPI ExitThread(IN DWORD uExitCode)
Definition: thread.c:365
unsigned long DWORD
Definition: ntddk_ex.h:95
static void collect_query_data(struct query *query)
Definition: pdh_main.c:445
#define PDH_MAGIC_QUERY
Definition: pdh_main.c:139
static CRITICAL_SECTION pdh_handle_cs
Definition: pdh_main.c:44
#define PDH_INVALID_HANDLE
Definition: pdhmsg.h:45
HANDLE wait
Definition: pdh_main.c:147
DWORD magic
Definition: pdh_main.c:143
DWORD interval
Definition: pdh_main.c:146
HANDLE stop
Definition: pdh_main.c:148
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
void * arg
Definition: msvc.h:10

Referenced by PdhCollectQueryDataEx().

◆ collect_uptime()

static void CALLBACK collect_uptime ( struct counter counter)
static

Definition at line 195 of file pdh_main.c.

196{
199}
ULONGLONG WINAPI GetTickCount64(VOID)
Definition: GetTickCount64.c:9

◆ create_counter()

static struct counter * create_counter ( void  )
static

Definition at line 120 of file pdh_main.c.

121{
122 struct counter *counter;
123
124 if ((counter = heap_alloc_zero( sizeof(struct counter) )))
125 {
127 return counter;
128 }
129 return NULL;
130}
#define NULL
Definition: types.h:112
#define PDH_MAGIC_COUNTER
Definition: pdh_main.c:118
DWORD magic
Definition: pdh_main.c:102

Referenced by PdhAddCounterW().

◆ create_query()

static struct query * create_query ( void  )
static

Definition at line 152 of file pdh_main.c.

153{
154 struct query *query;
155
156 if ((query = heap_alloc_zero( sizeof(struct query) )))
157 {
160 return query;
161 }
162 return NULL;
163}
static void list_init(struct list_entry *head)
Definition: list.h:51

Referenced by get_diskdrivetodiskpartition_pairs(), get_logicaldisktopartition_pairs(), msi_table_apply_transform(), PdhOpenQueryW(), and wbem_services_ExecMethod().

◆ destroy_counter()

static void destroy_counter ( struct counter counter)
static

Definition at line 132 of file pdh_main.c.

133{
134 counter->magic = 0;
137}
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
WCHAR * path
Definition: pdh_main.c:104

Referenced by PdhCloseQuery(), and PdhRemoveCounter().

◆ destroy_query()

static void destroy_query ( struct query query)
static

Definition at line 165 of file pdh_main.c.

166{
167 query->magic = 0;
168 heap_free( query );
169}

Referenced by PdhCloseQuery().

◆ DllMain()

BOOL WINAPI DllMain ( HINSTANCE  hinstDLL,
DWORD  fdwReason,
LPVOID  lpvReserved 
)

Definition at line 74 of file pdh_main.c.

75{
76 TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
77 switch (fdwReason)
78 {
79 case DLL_WINE_PREATTACH:
80 return FALSE; /* prefer native version */
83 break;
85 if (lpvReserved) break;
87 break;
88 }
89
90 return TRUE;
91}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define DLL_PROCESS_DETACH
Definition: compat.h:130
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
static IN DWORD IN LPVOID lpvReserved
#define TRACE(s)
Definition: solgame.cpp:4
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)

◆ format_value()

static PDH_STATUS format_value ( struct counter counter,
DWORD  format,
union value raw1,
union value raw2,
PDH_FMT_COUNTERVALUE value 
)
static

Definition at line 336 of file pdh_main.c.

338{
339 LONG factor;
340
342 if (format & PDH_FMT_LONG)
343 {
344 if (format & PDH_FMT_1000) value->u.longValue = raw2->longvalue * 1000;
345 else value->u.longValue = raw2->longvalue * pow( 10, factor );
346 }
347 else if (format & PDH_FMT_LARGE)
348 {
349 if (format & PDH_FMT_1000) value->u.largeValue = raw2->largevalue * 1000;
350 else value->u.largeValue = raw2->largevalue * pow( 10, factor );
351 }
352 else if (format & PDH_FMT_DOUBLE)
353 {
354 if (format & PDH_FMT_1000) value->u.doubleValue = raw2->doublevalue * 1000;
355 else value->u.doubleValue = raw2->doublevalue * pow( 10, factor );
356 }
357 else
358 {
359 WARN("unknown format %x\n", format);
361 }
362 return ERROR_SUCCESS;
363}
#define WARN(fmt,...)
Definition: debug.h:112
#define ERROR_SUCCESS
Definition: deptool.c:10
double pow(double x, double y)
Definition: freeldr.c:112
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint factor
Definition: glfuncs.h:178
#define PDH_FMT_LONG
Definition: pdh.h:49
#define PDH_FMT_DOUBLE
Definition: pdh.h:50
#define PDH_FMT_1000
Definition: pdh.h:53
#define PDH_FMT_LARGE
Definition: pdh.h:51
#define PDH_INVALID_ARGUMENT
Definition: pdhmsg.h:46
long LONG
Definition: pedump.c:60
LONG defaultscale
Definition: pdh_main.c:108
LONG scale
Definition: pdh_main.c:107
Definition: pdh_main.c:94
LONG longvalue
Definition: pdh_main.c:95
double doublevalue
Definition: pdh_main.c:96

Referenced by PdhCalculateCounterFromRawValue(), and PdhGetFormattedCounterValue().

◆ is_local_machine()

static BOOL is_local_machine ( const WCHAR name,
DWORD  len 
)
static

Definition at line 216 of file pdh_main.c.

217{
219 DWORD buflen = ARRAY_SIZE(buf);
220
221 if (!GetComputerNameW( buf, &buflen )) return FALSE;
222 return len == buflen && !_wcsnicmp( name, buf, buflen );
223}
#define ARRAY_SIZE(A)
Definition: main.h:33
BOOL WINAPI GetComputerNameW(LPWSTR lpBuffer, LPDWORD lpnSize)
Definition: compname.c:446
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLenum GLsizei len
Definition: glext.h:6722
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
Definition: name.c:39
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:243
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by pdh_match_path().

◆ pdh_match_path()

static BOOL pdh_match_path ( LPCWSTR  fullpath,
LPCWSTR  path 
)
static

Definition at line 225 of file pdh_main.c.

226{
227 const WCHAR *p;
228
229 if (path[0] == '\\' && path[1] == '\\' && (p = wcschr( path + 2, '\\' )) &&
230 is_local_machine( path + 2, p - path - 2 ))
231 {
232 path += p - path;
233 }
234 if (wcschr( path, '\\' )) p = fullpath;
235 else p = wcsrchr( fullpath, '\\' ) + 1;
236 return !wcscmp( p, path );
237}
#define wcschr
Definition: compat.h:17
#define wcsrchr
Definition: compat.h:16
GLfloat GLfloat p
Definition: glext.h:8902
static BOOL is_local_machine(const WCHAR *name, DWORD len)
Definition: pdh_main.c:216
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)

Referenced by PdhAddCounterW(), PdhLookupPerfIndexByNameW(), and PdhValidatePathW().

◆ pdh_strdup()

static WCHAR * pdh_strdup ( const WCHAR src)
inlinestatic

Definition at line 54 of file pdh_main.c.

55{
56 WCHAR *dst;
57
58 if (!src) return NULL;
59 if ((dst = heap_alloc( (lstrlenW( src ) + 1) * sizeof(WCHAR) ))) lstrcpyW( dst, src );
60 return dst;
61}
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
#define lstrcpyW
Definition: compat.h:749
#define lstrlenW
Definition: compat.h:750
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340

Referenced by PdhAddCounterW().

◆ pdh_strdup_aw()

static WCHAR * pdh_strdup_aw ( const char src)
inlinestatic

Definition at line 63 of file pdh_main.c.

64{
65 int len;
66 WCHAR *dst;
67
68 if (!src) return NULL;
69 len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
70 if ((dst = heap_alloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
71 return dst;
72}
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110

Referenced by PdhAddCounterA(), PdhLookupPerfIndexByNameA(), PdhLookupPerfNameByIndexA(), PdhMakeCounterPathA(), PdhOpenQueryA(), and PdhValidatePathA().

◆ PdhAddCounterA()

PDH_STATUS WINAPI PdhAddCounterA ( PDH_HQUERY  query,
LPCSTR  path,
DWORD_PTR  userdata,
PDH_HCOUNTER counter 
)

Definition at line 242 of file pdh_main.c.

244{
246 WCHAR *pathW;
247
248 TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
249
250 if (!path) return PDH_INVALID_ARGUMENT;
251
252 if (!(pathW = pdh_strdup_aw( path )))
254
255 ret = PdhAddCounterW( query, pathW, userdata, counter );
256
257 heap_free( pathW );
258 return ret;
259}
#define debugstr_a
Definition: kernel32.h:31
LONG PDH_STATUS
Definition: pdh.h:35
static WCHAR * pdh_strdup_aw(const char *src)
Definition: pdh_main.c:63
PDH_STATUS WINAPI PdhAddCounterW(PDH_HQUERY hquery, LPCWSTR path, DWORD_PTR userdata, PDH_HCOUNTER *hcounter)
Definition: pdh_main.c:264
#define PDH_MEMORY_ALLOCATION_FAILURE
Definition: pdhmsg.h:44
int ret

Referenced by PdhAddEnglishCounterA(), test_PdhAddCounterA(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), and test_PdhSetCounterScaleFactor().

◆ PdhAddCounterW()

PDH_STATUS WINAPI PdhAddCounterW ( PDH_HQUERY  hquery,
LPCWSTR  path,
DWORD_PTR  userdata,
PDH_HCOUNTER hcounter 
)

Definition at line 264 of file pdh_main.c.

266{
267 struct query *query = hquery;
268 struct counter *counter;
269 unsigned int i;
270
271 TRACE("%p %s %lx %p\n", hquery, debugstr_w(path), userdata, hcounter);
272
273 if (!path || !hcounter) return PDH_INVALID_ARGUMENT;
274
276 if (!query || query->magic != PDH_MAGIC_QUERY)
277 {
279 return PDH_INVALID_HANDLE;
280 }
281
282 *hcounter = NULL;
283 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
284 {
286 {
287 if ((counter = create_counter()))
288 {
290 counter->collect = counter_sources[i].collect;
291 counter->type = counter_sources[i].type;
293 counter->base = counter_sources[i].base;
295 counter->user = userdata;
296
298 *hcounter = counter;
299
301 return ERROR_SUCCESS;
302 }
305 }
306 }
309}
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define debugstr_w
Definition: kernel32.h:32
static WCHAR * pdh_strdup(const WCHAR *src)
Definition: pdh_main.c:54
static BOOL pdh_match_path(LPCWSTR fullpath, LPCWSTR path)
Definition: pdh_main.c:225
static struct counter * create_counter(void)
Definition: pdh_main.c:120
static const struct source counter_sources[]
Definition: pdh_main.c:209
#define PDH_CSTATUS_NO_COUNTER
Definition: pdhmsg.h:42
DWORD type
Definition: pdh_main.c:105
struct list entry
Definition: pdh_main.c:103
DWORD_PTR user
Definition: pdh_main.c:109
DWORD_PTR queryuser
Definition: pdh_main.c:110
LONGLONG base
Definition: pdh_main.c:111
DWORD_PTR user
Definition: pdh_main.c:144

Referenced by PdhAddCounterA(), PdhAddEnglishCounterW(), test_PdhAddCounterW(), and test_PdhGetCounterInfoW().

◆ PdhAddEnglishCounterA()

PDH_STATUS WINAPI PdhAddEnglishCounterA ( PDH_HQUERY  query,
LPCSTR  path,
DWORD_PTR  userdata,
PDH_HCOUNTER counter 
)

Definition at line 314 of file pdh_main.c.

316{
317 TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
318
319 if (!query) return PDH_INVALID_ARGUMENT;
320 return PdhAddCounterA( query, path, userdata, counter );
321}
PDH_STATUS WINAPI PdhAddCounterA(PDH_HQUERY query, LPCSTR path, DWORD_PTR userdata, PDH_HCOUNTER *counter)
Definition: pdh_main.c:242

Referenced by init_function_ptrs().

◆ PdhAddEnglishCounterW()

PDH_STATUS WINAPI PdhAddEnglishCounterW ( PDH_HQUERY  query,
LPCWSTR  path,
DWORD_PTR  userdata,
PDH_HCOUNTER counter 
)

Definition at line 326 of file pdh_main.c.

328{
329 TRACE("%p %s %lx %p\n", query, debugstr_w(path), userdata, counter);
330
331 if (!query) return PDH_INVALID_ARGUMENT;
332 return PdhAddCounterW( query, path, userdata, counter );
333}

Referenced by init_function_ptrs().

◆ PdhBindInputDataSourceA()

PDH_STATUS WINAPI PdhBindInputDataSourceA ( PDH_HLOG source,
const char filenamelist 
)

Definition at line 1298 of file pdh_main.c.

1299{
1300 FIXME("%p %s: stub\n", source, debugstr_a(filenamelist));
1301 return PDH_NOT_IMPLEMENTED;
1302}
#define FIXME(fmt,...)
Definition: debug.h:111
#define PDH_NOT_IMPLEMENTED
Definition: pdhmsg.h:68

◆ PdhBindInputDataSourceW()

PDH_STATUS WINAPI PdhBindInputDataSourceW ( PDH_HLOG source,
const WCHAR filenamelist 
)

Definition at line 1307 of file pdh_main.c.

1308{
1309 FIXME("%p %s: stub\n", source, debugstr_w(filenamelist));
1310 return PDH_NOT_IMPLEMENTED;
1311}

◆ PdhCalculateCounterFromRawValue()

PDH_STATUS WINAPI PdhCalculateCounterFromRawValue ( PDH_HCOUNTER  handle,
DWORD  format,
PPDH_RAW_COUNTER  raw1,
PPDH_RAW_COUNTER  raw2,
PPDH_FMT_COUNTERVALUE  value 
)

Definition at line 368 of file pdh_main.c.

371{
373 struct counter *counter = handle;
374
375 TRACE("%p 0x%08x %p %p %p\n", handle, format, raw1, raw2, value);
376
377 if (!value) return PDH_INVALID_ARGUMENT;
378
381 {
383 return PDH_INVALID_HANDLE;
384 }
385
386 ret = format_value( counter, format, (union value *)&raw1->SecondValue,
387 (union value *)&raw2->SecondValue, value );
388
390 return ret;
391}
static PDH_STATUS format_value(struct counter *counter, DWORD format, union value *raw1, union value *raw2, PDH_FMT_COUNTERVALUE *value)
Definition: pdh_main.c:336
LONGLONG SecondValue
Definition: pdh.h:78

◆ PdhCloseQuery()

PDH_STATUS WINAPI PdhCloseQuery ( PDH_HQUERY  handle)

Definition at line 397 of file pdh_main.c.

398{
399 struct query *query = handle;
400 struct list *item, *next;
401
402 TRACE("%p\n", handle);
403
405 if (!query || query->magic != PDH_MAGIC_QUERY)
406 {
408 return PDH_INVALID_HANDLE;
409 }
410
411 if (query->thread)
412 {
414 SetEvent( query->stop );
416
418
421 {
423 return ERROR_SUCCESS;
424 }
427 query->thread = NULL;
428 }
429
431 {
432 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
433
436 }
437
439
441 return ERROR_SUCCESS;
442}
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static HANDLE thread
Definition: service.c:33
#define CloseHandle
Definition: compat.h:739
#define INFINITE
Definition: serial.h:102
static void destroy_query(struct query *query)
Definition: pdh_main.c:165
static void destroy_counter(struct counter *counter)
Definition: pdh_main.c:132
static unsigned __int64 next
Definition: rand_nt.c:6
#define LIST_FOR_EACH_SAFE(cursor, cursor2, list)
Definition: list.h:192
HANDLE thread
Definition: pdh_main.c:145

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), test_PdhAddEnglishCounterW(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterInfoW(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), test_PdhOpenQueryA(), test_PdhOpenQueryW(), and test_PdhSetCounterScaleFactor().

◆ PdhCollectQueryData()

PDH_STATUS WINAPI PdhCollectQueryData ( PDH_HQUERY  handle)

Definition at line 464 of file pdh_main.c.

465{
466 struct query *query = handle;
467
468 TRACE("%p\n", handle);
469
471 if (!query || query->magic != PDH_MAGIC_QUERY)
472 {
474 return PDH_INVALID_HANDLE;
475 }
476
477 if (list_empty( &query->counters ))
478 {
480 return PDH_NO_DATA;
481 }
482
484
486 return ERROR_SUCCESS;
487}
static int list_empty(struct list_entry *head)
Definition: list.h:58
#define PDH_NO_DATA
Definition: pdhmsg.h:31

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), test_PdhAddEnglishCounterW(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetFormattedCounterValue(), and test_PdhGetRawCounterValue().

◆ PdhCollectQueryDataEx()

PDH_STATUS WINAPI PdhCollectQueryDataEx ( PDH_HQUERY  handle,
DWORD  interval,
HANDLE  event 
)

Definition at line 520 of file pdh_main.c.

521{
523 struct query *query = handle;
524
525 TRACE("%p %d %p\n", handle, interval, event);
526
528 if (!query || query->magic != PDH_MAGIC_QUERY)
529 {
531 return PDH_INVALID_HANDLE;
532 }
533 if (list_empty( &query->counters ))
534 {
536 return PDH_NO_DATA;
537 }
538 if (query->thread)
539 {
541 SetEvent( query->stop );
543
545
548 {
550 return PDH_INVALID_HANDLE;
551 }
553 query->thread = NULL;
554 }
555 else if (!(query->stop = CreateEventW( NULL, FALSE, FALSE, NULL )))
556 {
557 ret = GetLastError();
559 return ret;
560 }
561 query->wait = event;
562 query->interval = interval * 1000;
564 {
565 ret = GetLastError();
567
569 return ret;
570 }
571
573 return ERROR_SUCCESS;
574}
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
struct _cl_event * event
Definition: glext.h:7739
static DWORD CALLBACK collect_query_thread(void *arg)
Definition: pdh_main.c:489
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
DWORD WINAPI GetLastError(void)
Definition: except.c:1042

Referenced by test_PdhCollectQueryDataEx().

◆ PdhCollectQueryDataWithTime()

PDH_STATUS WINAPI PdhCollectQueryDataWithTime ( PDH_HQUERY  handle,
LONGLONG timestamp 
)

Definition at line 579 of file pdh_main.c.

580{
581 struct query *query = handle;
582 struct counter *counter;
583 struct list *item;
584
585 TRACE("%p %p\n", handle, timestamp);
586
587 if (!timestamp) return PDH_INVALID_ARGUMENT;
588
590 if (!query || query->magic != PDH_MAGIC_QUERY)
591 {
593 return PDH_INVALID_HANDLE;
594 }
595 if (list_empty( &query->counters ))
596 {
598 return PDH_NO_DATA;
599 }
600
602
604 counter = LIST_ENTRY( item, struct counter, entry );
605
607
609 return ERROR_SUCCESS;
610}
DWORD dwHighDateTime
Definition: mapidefs.h:66
DWORD dwLowDateTime
Definition: mapidefs.h:65
Definition: list.h:15
int64_t LONGLONG
Definition: typedefs.h:68

Referenced by init_function_ptrs().

◆ PdhEnumObjectItemsA()

PDH_STATUS WINAPI PdhEnumObjectItemsA ( LPCSTR  szDataSource,
LPCSTR  szMachineName,
LPCSTR  szObjectName,
LPSTR  mszCounterList,
LPDWORD  pcchCounterListLength,
LPSTR  mszInstanceList,
LPDWORD  pcchInstanceListLength,
DWORD  dwDetailLevel,
DWORD  dwFlags 
)

Definition at line 1243 of file pdh_main.c.

1246{
1247 FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_a(szDataSource), debugstr_a(szMachineName),
1248 debugstr_a(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
1249 pcchInstanceListLength, dwDetailLevel, dwFlags);
1250
1251 return PDH_NOT_IMPLEMENTED;
1252}
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

◆ PdhEnumObjectItemsW()

PDH_STATUS WINAPI PdhEnumObjectItemsW ( LPCWSTR  szDataSource,
LPCWSTR  szMachineName,
LPCWSTR  szObjectName,
LPWSTR  mszCounterList,
LPDWORD  pcchCounterListLength,
LPWSTR  mszInstanceList,
LPDWORD  pcchInstanceListLength,
DWORD  dwDetailLevel,
DWORD  dwFlags 
)

Definition at line 1257 of file pdh_main.c.

1260{
1261 FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_w(szDataSource), debugstr_w(szMachineName),
1262 debugstr_w(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
1263 pcchInstanceListLength, dwDetailLevel, dwFlags);
1264
1265 return PDH_NOT_IMPLEMENTED;
1266}

◆ PdhExpandCounterPathA()

PDH_STATUS WINAPI PdhExpandCounterPathA ( LPCSTR  szWildCardPath,
LPSTR  mszExpandedPathList,
LPDWORD  pcchPathListLength 
)

Definition at line 633 of file pdh_main.c.

634{
635 FIXME("%s, %p, %p: stub\n", debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength);
636 return PdhExpandWildCardPathA(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
637}
PDH_STATUS WINAPI PdhExpandWildCardPathA(LPCSTR szDataSource, LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags)
Definition: pdh_main.c:615

◆ PdhExpandCounterPathW()

PDH_STATUS WINAPI PdhExpandCounterPathW ( LPCWSTR  szWildCardPath,
LPWSTR  mszExpandedPathList,
LPDWORD  pcchPathListLength 
)

Definition at line 642 of file pdh_main.c.

643{
644 FIXME("%s, %p, %p: stub\n", debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength);
645 return PdhExpandWildCardPathW(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
646}
PDH_STATUS WINAPI PdhExpandWildCardPathW(LPCWSTR szDataSource, LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags)
Definition: pdh_main.c:624

◆ PdhExpandWildCardPathA()

PDH_STATUS WINAPI PdhExpandWildCardPathA ( LPCSTR  szDataSource,
LPCSTR  szWildCardPath,
LPSTR  mszExpandedPathList,
LPDWORD  pcchPathListLength,
DWORD  dwFlags 
)

Definition at line 615 of file pdh_main.c.

616{
617 FIXME("%s, %s, %p, %p, 0x%x: stub\n", debugstr_a(szDataSource), debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
618 return PDH_NOT_IMPLEMENTED;
619}

Referenced by PdhExpandCounterPathA().

◆ PdhExpandWildCardPathW()

PDH_STATUS WINAPI PdhExpandWildCardPathW ( LPCWSTR  szDataSource,
LPCWSTR  szWildCardPath,
LPWSTR  mszExpandedPathList,
LPDWORD  pcchPathListLength,
DWORD  dwFlags 
)

Definition at line 624 of file pdh_main.c.

625{
626 FIXME("%s, %s, %p, %p, 0x%x: stub\n", debugstr_w(szDataSource), debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
627 return PDH_NOT_IMPLEMENTED;
628}

Referenced by PdhExpandCounterPathW().

◆ PdhGetCounterInfoA()

PDH_STATUS WINAPI PdhGetCounterInfoA ( PDH_HCOUNTER  handle,
BOOLEAN  text,
LPDWORD  size,
PPDH_COUNTER_INFO_A  info 
)

Definition at line 651 of file pdh_main.c.

652{
653 struct counter *counter = handle;
654
655 TRACE("%p %d %p %p\n", handle, text, size, info);
656
659 {
661 return PDH_INVALID_HANDLE;
662 }
663 if (!size)
664 {
667 }
668 if (*size < sizeof(PDH_COUNTER_INFO_A))
669 {
670 *size = sizeof(PDH_COUNTER_INFO_A);
672 return PDH_MORE_DATA;
673 }
674
675 memset( info, 0, sizeof(PDH_COUNTER_INFO_A) );
676
677 info->dwType = counter->type;
678 info->CStatus = counter->status;
679 info->lScale = counter->scale;
680 info->lDefaultScale = counter->defaultscale;
681 info->dwUserData = counter->user;
682 info->dwQueryUserData = counter->queryuser;
683
684 *size = sizeof(PDH_COUNTER_INFO_A);
685
687 return ERROR_SUCCESS;
688}
const WCHAR * text
Definition: package.c:1799
GLsizeiptr size
Definition: glext.h:5919
struct _PDH_COUNTER_INFO_A PDH_COUNTER_INFO_A
#define PDH_MORE_DATA
Definition: pdhmsg.h:28
#define memset(x, y, z)
Definition: compat.h:39

Referenced by test_PdhGetCounterInfoA().

◆ PdhGetCounterInfoW()

PDH_STATUS WINAPI PdhGetCounterInfoW ( PDH_HCOUNTER  handle,
BOOLEAN  text,
LPDWORD  size,
PPDH_COUNTER_INFO_W  info 
)

Definition at line 693 of file pdh_main.c.

694{
695 struct counter *counter = handle;
696
697 TRACE("%p %d %p %p\n", handle, text, size, info);
698
701 {
703 return PDH_INVALID_HANDLE;
704 }
705 if (!size)
706 {
709 }
710 if (*size < sizeof(PDH_COUNTER_INFO_W))
711 {
712 *size = sizeof(PDH_COUNTER_INFO_W);
714 return PDH_MORE_DATA;
715 }
716
717 memset( info, 0, sizeof(PDH_COUNTER_INFO_W) );
718
719 info->dwType = counter->type;
720 info->CStatus = counter->status;
721 info->lScale = counter->scale;
722 info->lDefaultScale = counter->defaultscale;
723 info->dwUserData = counter->user;
724 info->dwQueryUserData = counter->queryuser;
725
726 *size = sizeof(PDH_COUNTER_INFO_W);
727
729 return ERROR_SUCCESS;
730}
struct _PDH_COUNTER_INFO_W PDH_COUNTER_INFO_W

Referenced by test_PdhGetCounterInfoW().

◆ PdhGetCounterTimeBase()

PDH_STATUS WINAPI PdhGetCounterTimeBase ( PDH_HCOUNTER  handle,
LONGLONG base 
)

Definition at line 735 of file pdh_main.c.

736{
737 struct counter *counter = handle;
738
739 TRACE("%p %p\n", handle, base);
740
741 if (!base) return PDH_INVALID_ARGUMENT;
742
745 {
747 return PDH_INVALID_HANDLE;
748 }
749
750 *base = counter->base;
751
753 return ERROR_SUCCESS;
754}

Referenced by test_PdhGetCounterTimeBase().

◆ PdhGetDllVersion()

PDH_STATUS WINAPI PdhGetDllVersion ( LPDWORD  version)

Definition at line 759 of file pdh_main.c.

760{
761 if (!version)
763
765
766 return ERROR_SUCCESS;
767}
static const WCHAR version[]
Definition: asmname.c:66
#define PDH_VERSION
Definition: pdh.h:42

Referenced by test_PdhGetDllVersion().

◆ PdhGetFormattedCounterValue()

PDH_STATUS WINAPI PdhGetFormattedCounterValue ( PDH_HCOUNTER  handle,
DWORD  format,
LPDWORD  type,
PPDH_FMT_COUNTERVALUE  value 
)

Definition at line 772 of file pdh_main.c.

774{
776 struct counter *counter = handle;
777
778 TRACE("%p %x %p %p\n", handle, format, type, value);
779
780 if (!value) return PDH_INVALID_ARGUMENT;
781
784 {
786 return PDH_INVALID_HANDLE;
787 }
788 if (counter->status)
789 {
791 return PDH_INVALID_DATA;
792 }
794 {
795 value->CStatus = ERROR_SUCCESS;
796 if (type) *type = counter->type;
797 }
798
800 return ret;
801}
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define PDH_INVALID_DATA
Definition: pdhmsg.h:55
union value one
Definition: pdh_main.c:114

Referenced by test_PdhCollectQueryDataEx(), and test_PdhGetFormattedCounterValue().

◆ PdhGetLogFileTypeA()

PDH_STATUS WINAPI PdhGetLogFileTypeA ( const char log,
DWORD type 
)

Definition at line 1280 of file pdh_main.c.

1281{
1282 FIXME("%s, %p: stub\n", debugstr_a(log), type);
1283 return PDH_NOT_IMPLEMENTED;
1284}
#define log(outFile, fmt,...)
Definition: util.h:15

◆ PdhGetLogFileTypeW()

PDH_STATUS WINAPI PdhGetLogFileTypeW ( const WCHAR log,
DWORD type 
)

Definition at line 1289 of file pdh_main.c.

1290{
1291 FIXME("%s, %p: stub\n", debugstr_w(log), type);
1292 return PDH_NOT_IMPLEMENTED;
1293}

◆ PdhGetRawCounterValue()

PDH_STATUS WINAPI PdhGetRawCounterValue ( PDH_HCOUNTER  handle,
LPDWORD  type,
PPDH_RAW_COUNTER  value 
)

Definition at line 806 of file pdh_main.c.

808{
809 struct counter *counter = handle;
810
811 TRACE("%p %p %p\n", handle, type, value);
812
813 if (!value) return PDH_INVALID_ARGUMENT;
814
817 {
819 return PDH_INVALID_HANDLE;
820 }
821
822 value->CStatus = counter->status;
823 value->TimeStamp.dwLowDateTime = counter->stamp.dwLowDateTime;
824 value->TimeStamp.dwHighDateTime = counter->stamp.dwHighDateTime;
825 value->FirstValue = counter->one.largevalue;
826 value->SecondValue = counter->two.largevalue;
827 value->MultiCount = 1; /* FIXME */
828
829 if (type) *type = counter->type;
830
832 return ERROR_SUCCESS;
833}

Referenced by test_PdhGetRawCounterValue().

◆ PdhLookupPerfIndexByNameA()

PDH_STATUS WINAPI PdhLookupPerfIndexByNameA ( LPCSTR  machine,
LPCSTR  name,
LPDWORD  index 
)

Definition at line 838 of file pdh_main.c.

839{
842 WCHAR *nameW;
843
844 TRACE("%s %s %p\n", debugstr_a(machine), debugstr_a(name), index);
845
846 if (!name) return PDH_INVALID_ARGUMENT;
847
849
850 if (!(nameW = pdh_strdup_aw( name )))
852
854
855 heap_free( nameW );
857 return ret;
858}
static const WCHAR nameW[]
Definition: main.c:46
GLuint index
Definition: glext.h:6031
static const WCHAR machineW[]
Definition: profile.c:105
static const char machine[]
Definition: profile.c:104
PDH_STATUS WINAPI PdhLookupPerfIndexByNameW(LPCWSTR machine, LPCWSTR name, LPDWORD index)
Definition: pdh_main.c:863

Referenced by test_PdhLookupPerfIndexByNameA().

◆ PdhLookupPerfIndexByNameW()

PDH_STATUS WINAPI PdhLookupPerfIndexByNameW ( LPCWSTR  machine,
LPCWSTR  name,
LPDWORD  index 
)

Definition at line 863 of file pdh_main.c.

864{
865 unsigned int i;
866
867 TRACE("%s %s %p\n", debugstr_w(machine), debugstr_w(name), index);
868
869 if (!name || !index) return PDH_INVALID_ARGUMENT;
870
871 if (machine)
872 {
873 FIXME("remote machine not supported\n");
875 }
876 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
877 {
879 {
880 *index = counter_sources[i].index;
881 return ERROR_SUCCESS;
882 }
883 }
885}
#define PDH_STRING_NOT_FOUND
Definition: pdhmsg.h:69
#define PDH_CSTATUS_NO_MACHINE
Definition: pdhmsg.h:26

Referenced by PdhLookupPerfIndexByNameA(), and test_PdhLookupPerfIndexByNameW().

◆ PdhLookupPerfNameByIndexA()

PDH_STATUS WINAPI PdhLookupPerfNameByIndexA ( LPCSTR  machine,
DWORD  index,
LPSTR  buffer,
LPDWORD  size 
)

Definition at line 890 of file pdh_main.c.

891{
895 DWORD sizeW = ARRAY_SIZE(bufferW);
896
897 TRACE("%s %d %p %p\n", debugstr_a(machine), index, buffer, size);
898
899 if (!buffer || !size) return PDH_INVALID_ARGUMENT;
900
902
903 if (!(ret = PdhLookupPerfNameByIndexW( machineW, index, bufferW, &sizeW )))
904 {
905 int required = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
906
907 if (*size < required) ret = PDH_MORE_DATA;
908 else WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, required, NULL, NULL );
909 *size = required;
910 }
912 return ret;
913}
#define WideCharToMultiByte
Definition: compat.h:111
static const WCHAR sizeW[]
Definition: editor.c:79
GLuint buffer
Definition: glext.h:5915
#define PDH_MAX_COUNTER_NAME
Definition: pdh.h:47
PDH_STATUS WINAPI PdhLookupPerfNameByIndexW(LPCWSTR machine, DWORD index, LPWSTR buffer, LPDWORD size)
Definition: pdh_main.c:918

Referenced by test_PdhLookupPerfNameByIndexA().

◆ PdhLookupPerfNameByIndexW()

PDH_STATUS WINAPI PdhLookupPerfNameByIndexW ( LPCWSTR  machine,
DWORD  index,
LPWSTR  buffer,
LPDWORD  size 
)

Definition at line 918 of file pdh_main.c.

919{
921 unsigned int i;
922
923 TRACE("%s %d %p %p\n", debugstr_w(machine), index, buffer, size);
924
925 if (machine)
926 {
927 FIXME("remote machine not supported\n");
929 }
930
931 if (!buffer || !size) return PDH_INVALID_ARGUMENT;
932 if (!index) return ERROR_SUCCESS;
933
934 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
935 {
937 {
938 WCHAR *p = wcsrchr( counter_sources[i].path, '\\' ) + 1;
939 unsigned int required = lstrlenW( p ) + 1;
940
941 if (*size < required) ret = PDH_MORE_DATA;
942 else
943 {
944 lstrcpyW( buffer, p );
946 }
947 *size = required;
948 return ret;
949 }
950 }
952}

Referenced by PdhLookupPerfNameByIndexA(), and test_PdhLookupPerfNameByIndexW().

◆ PdhMakeCounterPathA()

PDH_STATUS WINAPI PdhMakeCounterPathA ( PDH_COUNTER_PATH_ELEMENTS_A e,
LPSTR  buffer,
LPDWORD  buflen,
DWORD  flags 
)

Definition at line 1137 of file pdh_main.c.

1139{
1142 WCHAR *bufferW;
1143 DWORD buflenW;
1144
1145 TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);
1146
1147 if (!e || !buflen) return PDH_INVALID_ARGUMENT;
1148
1149 memset( &eW, 0, sizeof(eW) );
1150 if (e->szMachineName && !(eW.szMachineName = pdh_strdup_aw( e->szMachineName ))) goto done;
1151 if (e->szObjectName && !(eW.szObjectName = pdh_strdup_aw( e->szObjectName ))) goto done;
1152 if (e->szInstanceName && !(eW.szInstanceName = pdh_strdup_aw( e->szInstanceName ))) goto done;
1153 if (e->szParentInstance && !(eW.szParentInstance = pdh_strdup_aw( e->szParentInstance ))) goto done;
1154 if (e->szCounterName && !(eW.szCounterName = pdh_strdup_aw( e->szCounterName ))) goto done;
1155 eW.dwInstanceIndex = e->dwInstanceIndex;
1156
1157 buflenW = 0;
1158 ret = PdhMakeCounterPathW( &eW, NULL, &buflenW, flags );
1159 if (ret == PDH_MORE_DATA)
1160 {
1161 if ((bufferW = heap_alloc( buflenW * sizeof(WCHAR) )))
1162 {
1163 if (!(ret = PdhMakeCounterPathW( &eW, bufferW, &buflenW, flags )))
1164 {
1165 int len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
1166 if (*buflen >= len) WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, *buflen, NULL, NULL);
1167 else ret = PDH_MORE_DATA;
1168 *buflen = len;
1169 }
1170 heap_free( bufferW );
1171 }
1172 else
1174 }
1175
1176done:
1178 heap_free( eW.szObjectName );
1182 return ret;
1183}
GLbitfield flags
Definition: glext.h:7161
#define e
Definition: ke_i.h:82
PDH_STATUS WINAPI PdhMakeCounterPathW(PDH_COUNTER_PATH_ELEMENTS_W *e, LPWSTR buffer, LPDWORD buflen, DWORD flags)
Definition: pdh_main.c:1188

Referenced by test_PdhMakeCounterPathA().

◆ PdhMakeCounterPathW()

PDH_STATUS WINAPI PdhMakeCounterPathW ( PDH_COUNTER_PATH_ELEMENTS_W e,
LPWSTR  buffer,
LPDWORD  buflen,
DWORD  flags 
)

Definition at line 1188 of file pdh_main.c.

1190{
1191 static const WCHAR bslash[] = {'\\',0};
1192 static const WCHAR fslash[] = {'/',0};
1193 static const WCHAR lparen[] = {'(',0};
1194 static const WCHAR rparen[] = {')',0};
1195 static const WCHAR fmt[] = {'#','%','u',0};
1196
1199 DWORD len;
1200
1201 TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);
1202
1203 if (flags) FIXME("unimplemented flags 0x%08x\n", flags);
1204
1205 if (!e || !e->szCounterName || !e->szObjectName || !buflen)
1206 return PDH_INVALID_ARGUMENT;
1207
1208 path[0] = 0;
1209 if (e->szMachineName)
1210 {
1211 lstrcatW(path, bslash);
1212 lstrcatW(path, bslash);
1213 lstrcatW(path, e->szMachineName);
1214 }
1215 lstrcatW(path, bslash);
1216 lstrcatW(path, e->szObjectName);
1217 if (e->szInstanceName)
1218 {
1219 lstrcatW(path, lparen);
1220 if (e->szParentInstance)
1221 {
1222 lstrcatW(path, e->szParentInstance);
1223 lstrcatW(path, fslash);
1224 }
1225 lstrcatW(path, e->szInstanceName);
1226 swprintf(instance, fmt, e->dwInstanceIndex);
1228 lstrcatW(path, rparen);
1229 }
1230 lstrcatW(path, bslash);
1231 lstrcatW(path, e->szCounterName);
1232
1233 len = lstrlenW(path) + 1;
1234 if (*buflen >= len) lstrcpyW(buffer, path);
1235 else ret = PDH_MORE_DATA;
1236 *buflen = len;
1237 return ret;
1238}
static HINSTANCE instance
Definition: main.c:40
#define swprintf
Definition: precomp.h:40
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
Definition: dsound.c:943

Referenced by PdhMakeCounterPathA().

◆ PdhOpenQueryA()

PDH_STATUS WINAPI PdhOpenQueryA ( LPCSTR  source,
DWORD_PTR  userdata,
PDH_HQUERY query 
)

Definition at line 957 of file pdh_main.c.

958{
960 WCHAR *sourceW = NULL;
961
962 TRACE("%s %lx %p\n", debugstr_a(source), userdata, query);
963
965
966 ret = PdhOpenQueryW( sourceW, userdata, query );
968
969 return ret;
970}
static const WCHAR sourceW[]
Definition: jsregexp.c:37
PDH_STATUS WINAPI PdhOpenQueryW(LPCWSTR source, DWORD_PTR userdata, PDH_HQUERY *handle)
Definition: pdh_main.c:975

Referenced by test_PdhAddCounterA(), test_PdhAddEnglishCounterA(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), test_PdhOpenQueryA(), and test_PdhSetCounterScaleFactor().

◆ PdhOpenQueryW()

PDH_STATUS WINAPI PdhOpenQueryW ( LPCWSTR  source,
DWORD_PTR  userdata,
PDH_HQUERY handle 
)

Definition at line 975 of file pdh_main.c.

976{
977 struct query *query;
978
979 TRACE("%s %lx %p\n", debugstr_w(source), userdata, handle);
980
981 if (!handle) return PDH_INVALID_ARGUMENT;
982
983 if (source)
984 {
985 FIXME("log file data source not supported\n");
987 }
988 if ((query = create_query()))
989 {
990 query->user = userdata;
991 *handle = query;
992
993 return ERROR_SUCCESS;
994 }
996}
static struct query * create_query(void)
Definition: pdh_main.c:152

Referenced by PdhOpenQueryA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterW(), test_PdhGetCounterInfoW(), and test_PdhOpenQueryW().

◆ PdhRemoveCounter()

PDH_STATUS WINAPI PdhRemoveCounter ( PDH_HCOUNTER  handle)

Definition at line 1001 of file pdh_main.c.

1002{
1003 struct counter *counter = handle;
1004
1005 TRACE("%p\n", handle);
1006
1009 {
1011 return PDH_INVALID_HANDLE;
1012 }
1013
1016
1018 return ERROR_SUCCESS;
1019}

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), and test_PdhAddEnglishCounterW().

◆ PdhSetCounterScaleFactor()

PDH_STATUS WINAPI PdhSetCounterScaleFactor ( PDH_HCOUNTER  handle,
LONG  factor 
)

Definition at line 1024 of file pdh_main.c.

1025{
1026 struct counter *counter = handle;
1027
1028 TRACE("%p\n", handle);
1029
1032 {
1034 return PDH_INVALID_HANDLE;
1035 }
1036 if (factor < PDH_MIN_SCALE || factor > PDH_MAX_SCALE)
1037 {
1039 return PDH_INVALID_ARGUMENT;
1040 }
1041
1042 counter->scale = factor;
1043
1045 return ERROR_SUCCESS;
1046}
#define PDH_MAX_SCALE
Definition: pdh.h:44

Referenced by test_PdhGetCounterInfoA(), test_PdhGetCounterInfoW(), test_PdhGetFormattedCounterValue(), and test_PdhSetCounterScaleFactor().

◆ PdhSetDefaultRealTimeDataSource()

PDH_STATUS WINAPI PdhSetDefaultRealTimeDataSource ( DWORD  source)

Definition at line 1271 of file pdh_main.c.

1272{
1273 FIXME("%u\n", source);
1274 return ERROR_SUCCESS;
1275}

◆ PdhValidatePathA()

PDH_STATUS WINAPI PdhValidatePathA ( LPCSTR  path)

Definition at line 1051 of file pdh_main.c.

1052{
1054 WCHAR *pathW;
1055
1056 TRACE("%s\n", debugstr_a(path));
1057
1058 if (!path) return PDH_INVALID_ARGUMENT;
1059 if (!(pathW = pdh_strdup_aw( path ))) return PDH_MEMORY_ALLOCATION_FAILURE;
1060
1061 ret = PdhValidatePathW( pathW );
1062
1063 heap_free( pathW );
1064 return ret;
1065}
PDH_STATUS WINAPI PdhValidatePathW(LPCWSTR path)
Definition: pdh_main.c:1077

Referenced by PdhValidatePathExA(), and test_PdhValidatePathA().

◆ PdhValidatePathExA()

PDH_STATUS WINAPI PdhValidatePathExA ( PDH_HLOG  source,
LPCSTR  path 
)

Definition at line 1107 of file pdh_main.c.

1108{
1109 TRACE("%p %s\n", source, debugstr_a(path));
1110
1111 if (source)
1112 {
1113 FIXME("log file data source not supported\n");
1114 return ERROR_SUCCESS;
1115 }
1116 return PdhValidatePathA( path );
1117}
PDH_STATUS WINAPI PdhValidatePathA(LPCSTR path)
Definition: pdh_main.c:1051

Referenced by init_function_ptrs().

◆ PdhValidatePathExW()

PDH_STATUS WINAPI PdhValidatePathExW ( PDH_HLOG  source,
LPCWSTR  path 
)

Definition at line 1122 of file pdh_main.c.

1123{
1124 TRACE("%p %s\n", source, debugstr_w(path));
1125
1126 if (source)
1127 {
1128 FIXME("log file data source not supported\n");
1129 return ERROR_SUCCESS;
1130 }
1131 return PdhValidatePathW( path );
1132}

Referenced by init_function_ptrs().

◆ PdhValidatePathW()

PDH_STATUS WINAPI PdhValidatePathW ( LPCWSTR  path)

Definition at line 1077 of file pdh_main.c.

1078{
1080 unsigned int i;
1081
1082 TRACE("%s\n", debugstr_w(path));
1083
1084 if ((ret = validate_path( path ))) return ret;
1085
1086 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
1088
1090}
static PDH_STATUS validate_path(LPCWSTR path)
Definition: pdh_main.c:1067

Referenced by PdhValidatePathA(), PdhValidatePathExW(), and test_PdhValidatePathW().

◆ PdhVbAddCounter()

PDH_STATUS WINAPI PdhVbAddCounter ( PDH_HQUERY  query,
LPCSTR  path,
PDH_HCOUNTER counter 
)

Definition at line 1095 of file pdh_main.c.

1096{
1097 FIXME("%p, %s, %p: stub!\n", query, debugstr_a(path), counter);
1098
1099 if (!path) return PDH_INVALID_ARGUMENT;
1100
1101 return PDH_NOT_IMPLEMENTED;
1102}

◆ validate_path()

static PDH_STATUS validate_path ( LPCWSTR  path)
static

Definition at line 1067 of file pdh_main.c.

1068{
1069 if (!path || !*path) return PDH_INVALID_ARGUMENT;
1070 if (*path++ != '\\' || !wcschr( path, '\\' )) return PDH_CSTATUS_BAD_COUNTERNAME;
1071 return ERROR_SUCCESS;
1072 }
#define PDH_CSTATUS_BAD_COUNTERNAME
Definition: pdhmsg.h:49

Referenced by PdhValidatePathW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( pdh  )

Variable Documentation

◆ counter_sources

const struct source counter_sources[]
static
Initial value:
=
{
{ 238, path_processor, NULL, 0, 0, 0 },
{ 674, path_uptime, collect_uptime, TYPE_UPTIME, -3, 1000 }
}
static void CALLBACK collect_uptime(struct counter *counter)
Definition: pdh_main.c:195
static const WCHAR path_uptime[]
Definition: pdh_main.c:186
#define TYPE_PROCESSOR_TIME
Definition: pdh_main.c:201
static const WCHAR path_processor[]
Definition: pdh_main.c:184
static const WCHAR path_processor_time[]
Definition: pdh_main.c:181
#define TYPE_UPTIME
Definition: pdh_main.c:205
static void CALLBACK collect_processor_time(struct counter *counter)
Definition: pdh_main.c:189

Definition at line 209 of file pdh_main.c.

Referenced by PdhAddCounterW(), PdhLookupPerfIndexByNameW(), PdhLookupPerfNameByIndexW(), and PdhValidatePathW().

◆ path_processor

const WCHAR path_processor[]
static
Initial value:
=
{'\\','P','r','o','c','e','s','s','o','r',0}

Definition at line 184 of file pdh_main.c.

◆ path_processor_time

const WCHAR path_processor_time[]
static
Initial value:
=
{'\\','P','r','o','c','e','s','s','o','r','(','_','T','o','t','a','l',')',
'\\','%',' ','P','r','o','c','e','s','s','o','r',' ','T','i','m','e',0}

Definition at line 181 of file pdh_main.c.

◆ path_uptime

const WCHAR path_uptime[]
static
Initial value:
=
{'\\','S','y','s','t','e','m', '\\', 'S','y','s','t','e','m',' ','U','p',' ','T','i','m','e',0}

Definition at line 186 of file pdh_main.c.

◆ pdh_handle_cs

◆ pdh_handle_cs_debug

CRITICAL_SECTION_DEBUG pdh_handle_cs_debug
static
Initial value:
=
{
0, 0, &pdh_handle_cs,
0, 0, { (DWORD_PTR)(__FILE__ ": pdh_handle_cs") }
}
static CRITICAL_SECTION_DEBUG pdh_handle_cs_debug
Definition: pdh_main.c:45
LIST_ENTRY ProcessLocksList
Definition: winbase.h:883
#define DWORD_PTR
Definition: treelist.c:76

Definition at line 45 of file pdh_main.c.