[PDH]
[reactos.git] / reactos / dll / win32 / pdh / pdh_main.c
1 /*
2 * Performance Data Helper (pdh.dll)
3 *
4 * Copyright 2007 Andrey Turkin
5 * Copyright 2007 Hans Leidekker
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <math.h>
24
25 #define NONAMELESSUNION
26 #define NONAMELESSSTRUCT
27 #include "windef.h"
28 #include "winbase.h"
29
30 #include "pdh.h"
31 #include "pdhmsg.h"
32 #include "winperf.h"
33
34 #include "wine/debug.h"
35 #include "wine/list.h"
36 #include "wine/unicode.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(pdh);
39
40 static CRITICAL_SECTION pdh_handle_cs;
41 static CRITICAL_SECTION_DEBUG pdh_handle_cs_debug =
42 {
43 0, 0, &pdh_handle_cs,
44 { &pdh_handle_cs_debug.ProcessLocksList,
45 &pdh_handle_cs_debug.ProcessLocksList },
46 0, 0, { (DWORD_PTR)(__FILE__ ": pdh_handle_cs") }
47 };
48 static CRITICAL_SECTION pdh_handle_cs = { &pdh_handle_cs_debug, -1, 0, 0, 0, 0 };
49
50 static inline void *heap_alloc( SIZE_T size )
51 {
52 return HeapAlloc( GetProcessHeap(), 0, size );
53 }
54
55 static inline void *heap_alloc_zero( SIZE_T size )
56 {
57 return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
58 }
59
60 static inline void heap_free( LPVOID mem )
61 {
62 HeapFree( GetProcessHeap(), 0, mem );
63 }
64
65 static inline WCHAR *pdh_strdup( const WCHAR *src )
66 {
67 WCHAR *dst;
68
69 if (!src) return NULL;
70 if ((dst = heap_alloc( (strlenW( src ) + 1) * sizeof(WCHAR) ))) strcpyW( dst, src );
71 return dst;
72 }
73
74 static inline WCHAR *pdh_strdup_aw( const char *src )
75 {
76 int len;
77 WCHAR *dst;
78
79 if (!src) return NULL;
80 len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
81 if ((dst = heap_alloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
82 return dst;
83 }
84
85 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
86 {
87 TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
88
89 if (fdwReason == DLL_WINE_PREATTACH) return FALSE; /* prefer native version */
90
91 if (fdwReason == DLL_PROCESS_ATTACH)
92 {
93 DisableThreadLibraryCalls( hinstDLL );
94 }
95
96 return TRUE;
97 }
98
99 union value
100 {
101 LONG longvalue;
102 double doublevalue;
103 LONGLONG largevalue;
104 };
105
106 struct counter
107 {
108 DWORD magic; /* signature */
109 struct list entry; /* list entry */
110 WCHAR *path; /* identifier */
111 DWORD type; /* counter type */
112 DWORD status; /* update status */
113 LONG scale; /* scale factor */
114 LONG defaultscale; /* default scale factor */
115 DWORD_PTR user; /* user data */
116 DWORD_PTR queryuser; /* query user data */
117 LONGLONG base; /* samples per second */
118 FILETIME stamp; /* time stamp */
119 void (CALLBACK *collect)( struct counter * ); /* collect callback */
120 union value one; /* first value */
121 union value two; /* second value */
122 };
123
124 #define PDH_MAGIC_COUNTER 0x50444831 /* 'PDH1' */
125
126 static struct counter *create_counter( void )
127 {
128 struct counter *counter;
129
130 if ((counter = heap_alloc_zero( sizeof(struct counter) )))
131 {
132 counter->magic = PDH_MAGIC_COUNTER;
133 return counter;
134 }
135 return NULL;
136 }
137
138 static void destroy_counter( struct counter *counter )
139 {
140 counter->magic = 0;
141 heap_free( counter->path );
142 heap_free( counter );
143 }
144
145 #define PDH_MAGIC_QUERY 0x50444830 /* 'PDH0' */
146
147 struct query
148 {
149 DWORD magic; /* signature */
150 DWORD_PTR user; /* user data */
151 HANDLE thread; /* collect thread */
152 DWORD interval; /* collect interval */
153 HANDLE wait; /* wait event */
154 HANDLE stop; /* stop event */
155 struct list counters; /* counter list */
156 };
157
158 static struct query *create_query( void )
159 {
160 struct query *query;
161
162 if ((query = heap_alloc_zero( sizeof(struct query) )))
163 {
164 query->magic = PDH_MAGIC_QUERY;
165 list_init( &query->counters );
166 return query;
167 }
168 return NULL;
169 }
170
171 static void destroy_query( struct query *query )
172 {
173 query->magic = 0;
174 heap_free( query );
175 }
176
177 struct source
178 {
179 DWORD index; /* name index */
180 const WCHAR *path; /* identifier */
181 void (CALLBACK *collect)( struct counter * ); /* collect callback */
182 DWORD type; /* counter type */
183 LONG scale; /* default scale factor */
184 LONGLONG base; /* samples per second */
185 };
186
187 static const WCHAR path_processor_time[] =
188 {'\\','P','r','o','c','e','s','s','o','r','(','_','T','o','t','a','l',')',
189 '\\','%',' ','P','r','o','c','e','s','s','o','r',' ','T','i','m','e',0};
190 static const WCHAR path_uptime[] =
191 {'\\','S','y','s','t','e','m', '\\', 'S','y','s','t','e','m',' ','U','p',' ','T','i','m','e',0};
192
193 static void CALLBACK collect_processor_time( struct counter *counter )
194 {
195 counter->two.largevalue = 500000; /* FIXME */
196 counter->status = PDH_CSTATUS_VALID_DATA;
197 }
198
199 static void CALLBACK collect_uptime( struct counter *counter )
200 {
201 counter->two.largevalue = GetTickCount64();
202 counter->status = PDH_CSTATUS_VALID_DATA;
203 }
204
205 #define TYPE_PROCESSOR_TIME \
206 (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | \
207 PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)
208
209 #define TYPE_UPTIME \
210 (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)
211
212 /* counter source registry */
213 static const struct source counter_sources[] =
214 {
215 { 6, path_processor_time, collect_processor_time, TYPE_PROCESSOR_TIME, -5, 10000000 },
216 { 674, path_uptime, collect_uptime, TYPE_UPTIME, -3, 1000 }
217 };
218
219 static BOOL pdh_match_path( LPCWSTR fullpath, LPCWSTR path )
220 {
221 const WCHAR *p;
222
223 if (strchrW( path, '\\')) p = fullpath;
224 else p = strrchrW( fullpath, '\\' ) + 1;
225 if (strcmpW( p, path )) return FALSE;
226 return TRUE;
227 }
228
229 /***********************************************************************
230 * PdhAddCounterA (PDH.@)
231 */
232 PDH_STATUS WINAPI PdhAddCounterA( PDH_HQUERY query, LPCSTR path,
233 DWORD_PTR userdata, PDH_HCOUNTER *counter )
234 {
235 PDH_STATUS ret;
236 WCHAR *pathW;
237
238 TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
239
240 if (!path) return PDH_INVALID_ARGUMENT;
241
242 if (!(pathW = pdh_strdup_aw( path )))
243 return PDH_MEMORY_ALLOCATION_FAILURE;
244
245 ret = PdhAddCounterW( query, pathW, userdata, counter );
246
247 heap_free( pathW );
248 return ret;
249 }
250
251 /***********************************************************************
252 * PdhAddCounterW (PDH.@)
253 */
254 PDH_STATUS WINAPI PdhAddCounterW( PDH_HQUERY hquery, LPCWSTR path,
255 DWORD_PTR userdata, PDH_HCOUNTER *hcounter )
256 {
257 struct query *query = hquery;
258 struct counter *counter;
259 unsigned int i;
260
261 TRACE("%p %s %lx %p\n", hquery, debugstr_w(path), userdata, hcounter);
262
263 if (!path || !hcounter) return PDH_INVALID_ARGUMENT;
264
265 EnterCriticalSection( &pdh_handle_cs );
266 if (!query || query->magic != PDH_MAGIC_QUERY)
267 {
268 LeaveCriticalSection( &pdh_handle_cs );
269 return PDH_INVALID_HANDLE;
270 }
271
272 *hcounter = NULL;
273 for (i = 0; i < sizeof(counter_sources) / sizeof(counter_sources[0]); i++)
274 {
275 if (pdh_match_path( counter_sources[i].path, path ))
276 {
277 if ((counter = create_counter()))
278 {
279 counter->path = pdh_strdup( counter_sources[i].path );
280 counter->collect = counter_sources[i].collect;
281 counter->type = counter_sources[i].type;
282 counter->defaultscale = counter_sources[i].scale;
283 counter->base = counter_sources[i].base;
284 counter->queryuser = query->user;
285 counter->user = userdata;
286
287 list_add_tail( &query->counters, &counter->entry );
288 *hcounter = counter;
289
290 LeaveCriticalSection( &pdh_handle_cs );
291 return ERROR_SUCCESS;
292 }
293 LeaveCriticalSection( &pdh_handle_cs );
294 return PDH_MEMORY_ALLOCATION_FAILURE;
295 }
296 }
297 LeaveCriticalSection( &pdh_handle_cs );
298 return PDH_CSTATUS_NO_COUNTER;
299 }
300
301 /***********************************************************************
302 * PdhAddEnglishCounterA (PDH.@)
303 */
304 PDH_STATUS WINAPI PdhAddEnglishCounterA( PDH_HQUERY query, LPCSTR path,
305 DWORD_PTR userdata, PDH_HCOUNTER *counter )
306 {
307 TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
308
309 if (!query) return PDH_INVALID_ARGUMENT;
310 return PdhAddCounterA( query, path, userdata, counter );
311 }
312
313 /***********************************************************************
314 * PdhAddEnglishCounterW (PDH.@)
315 */
316 PDH_STATUS WINAPI PdhAddEnglishCounterW( PDH_HQUERY query, LPCWSTR path,
317 DWORD_PTR userdata, PDH_HCOUNTER *counter )
318 {
319 TRACE("%p %s %lx %p\n", query, debugstr_w(path), userdata, counter);
320
321 if (!query) return PDH_INVALID_ARGUMENT;
322 return PdhAddCounterW( query, path, userdata, counter );
323 }
324
325 /* caller must hold counter lock */
326 static PDH_STATUS format_value( struct counter *counter, DWORD format, union value *raw1,
327 union value *raw2, PDH_FMT_COUNTERVALUE *value )
328 {
329 LONG factor;
330
331 factor = counter->scale ? counter->scale : counter->defaultscale;
332 if (format & PDH_FMT_LONG)
333 {
334 if (format & PDH_FMT_1000) value->u.longValue = raw2->longvalue * 1000;
335 else value->u.longValue = raw2->longvalue * pow( 10, factor );
336 }
337 else if (format & PDH_FMT_LARGE)
338 {
339 if (format & PDH_FMT_1000) value->u.largeValue = raw2->largevalue * 1000;
340 else value->u.largeValue = raw2->largevalue * pow( 10, factor );
341 }
342 else if (format & PDH_FMT_DOUBLE)
343 {
344 if (format & PDH_FMT_1000) value->u.doubleValue = raw2->doublevalue * 1000;
345 else value->u.doubleValue = raw2->doublevalue * pow( 10, factor );
346 }
347 else
348 {
349 WARN("unknown format %x\n", format);
350 return PDH_INVALID_ARGUMENT;
351 }
352 return ERROR_SUCCESS;
353 }
354
355 /***********************************************************************
356 * PdhCalculateCounterFromRawValue (PDH.@)
357 */
358 PDH_STATUS WINAPI PdhCalculateCounterFromRawValue( PDH_HCOUNTER handle, DWORD format,
359 PPDH_RAW_COUNTER raw1, PPDH_RAW_COUNTER raw2,
360 PPDH_FMT_COUNTERVALUE value )
361 {
362 PDH_STATUS ret;
363 struct counter *counter = handle;
364
365 TRACE("%p 0x%08x %p %p %p\n", handle, format, raw1, raw2, value);
366
367 if (!value) return PDH_INVALID_ARGUMENT;
368
369 EnterCriticalSection( &pdh_handle_cs );
370 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
371 {
372 LeaveCriticalSection( &pdh_handle_cs );
373 return PDH_INVALID_HANDLE;
374 }
375
376 ret = format_value( counter, format, (union value *)&raw1->SecondValue,
377 (union value *)&raw2->SecondValue, value );
378
379 LeaveCriticalSection( &pdh_handle_cs );
380 return ret;
381 }
382
383
384 /***********************************************************************
385 * PdhCloseQuery (PDH.@)
386 */
387 PDH_STATUS WINAPI PdhCloseQuery( PDH_HQUERY handle )
388 {
389 struct query *query = handle;
390 struct list *item, *next;
391
392 TRACE("%p\n", handle);
393
394 EnterCriticalSection( &pdh_handle_cs );
395 if (!query || query->magic != PDH_MAGIC_QUERY)
396 {
397 LeaveCriticalSection( &pdh_handle_cs );
398 return PDH_INVALID_HANDLE;
399 }
400
401 if (query->thread)
402 {
403 HANDLE thread = query->thread;
404 SetEvent( query->stop );
405 LeaveCriticalSection( &pdh_handle_cs );
406
407 WaitForSingleObject( thread, INFINITE );
408
409 EnterCriticalSection( &pdh_handle_cs );
410 if (query->magic != PDH_MAGIC_QUERY)
411 {
412 LeaveCriticalSection( &pdh_handle_cs );
413 return ERROR_SUCCESS;
414 }
415 CloseHandle( query->stop );
416 CloseHandle( query->thread );
417 query->thread = NULL;
418 }
419
420 LIST_FOR_EACH_SAFE( item, next, &query->counters )
421 {
422 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
423
424 list_remove( &counter->entry );
425 destroy_counter( counter );
426 }
427
428 destroy_query( query );
429
430 LeaveCriticalSection( &pdh_handle_cs );
431 return ERROR_SUCCESS;
432 }
433
434 /* caller must hold query lock */
435 static void collect_query_data( struct query *query )
436 {
437 struct list *item;
438
439 LIST_FOR_EACH( item, &query->counters )
440 {
441 SYSTEMTIME time;
442 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
443
444 counter->collect( counter );
445
446 GetLocalTime( &time );
447 SystemTimeToFileTime( &time, &counter->stamp );
448 }
449 }
450
451 /***********************************************************************
452 * PdhCollectQueryData (PDH.@)
453 */
454 PDH_STATUS WINAPI PdhCollectQueryData( PDH_HQUERY handle )
455 {
456 struct query *query = handle;
457
458 TRACE("%p\n", handle);
459
460 EnterCriticalSection( &pdh_handle_cs );
461 if (!query || query->magic != PDH_MAGIC_QUERY)
462 {
463 LeaveCriticalSection( &pdh_handle_cs );
464 return PDH_INVALID_HANDLE;
465 }
466
467 if (list_empty( &query->counters ))
468 {
469 LeaveCriticalSection( &pdh_handle_cs );
470 return PDH_NO_DATA;
471 }
472
473 collect_query_data( query );
474
475 LeaveCriticalSection( &pdh_handle_cs );
476 return ERROR_SUCCESS;
477 }
478
479 static DWORD CALLBACK collect_query_thread( void *arg )
480 {
481 struct query *query = arg;
482 DWORD interval = query->interval;
483 HANDLE stop = query->stop;
484
485 for (;;)
486 {
487 if (WaitForSingleObject( stop, interval ) != WAIT_TIMEOUT) ExitThread( 0 );
488
489 EnterCriticalSection( &pdh_handle_cs );
490 if (query->magic != PDH_MAGIC_QUERY)
491 {
492 LeaveCriticalSection( &pdh_handle_cs );
493 ExitThread( PDH_INVALID_HANDLE );
494 }
495
496 collect_query_data( query );
497
498 if (!SetEvent( query->wait ))
499 {
500 LeaveCriticalSection( &pdh_handle_cs );
501 ExitThread( 0 );
502 }
503 LeaveCriticalSection( &pdh_handle_cs );
504 }
505 }
506
507 /***********************************************************************
508 * PdhCollectQueryDataEx (PDH.@)
509 */
510 PDH_STATUS WINAPI PdhCollectQueryDataEx( PDH_HQUERY handle, DWORD interval, HANDLE event )
511 {
512 PDH_STATUS ret;
513 struct query *query = handle;
514
515 TRACE("%p %d %p\n", handle, interval, event);
516
517 EnterCriticalSection( &pdh_handle_cs );
518 if (!query || query->magic != PDH_MAGIC_QUERY)
519 {
520 LeaveCriticalSection( &pdh_handle_cs );
521 return PDH_INVALID_HANDLE;
522 }
523 if (list_empty( &query->counters ))
524 {
525 LeaveCriticalSection( &pdh_handle_cs );
526 return PDH_NO_DATA;
527 }
528 if (query->thread)
529 {
530 HANDLE thread = query->thread;
531 SetEvent( query->stop );
532 LeaveCriticalSection( &pdh_handle_cs );
533
534 WaitForSingleObject( thread, INFINITE );
535
536 EnterCriticalSection( &pdh_handle_cs );
537 if (query->magic != PDH_MAGIC_QUERY)
538 {
539 LeaveCriticalSection( &pdh_handle_cs );
540 return PDH_INVALID_HANDLE;
541 }
542 CloseHandle( query->thread );
543 query->thread = NULL;
544 }
545 else if (!(query->stop = CreateEventW( NULL, FALSE, FALSE, NULL )))
546 {
547 ret = GetLastError();
548 LeaveCriticalSection( &pdh_handle_cs );
549 return ret;
550 }
551 query->wait = event;
552 query->interval = interval * 1000;
553 if (!(query->thread = CreateThread( NULL, 0, collect_query_thread, query, 0, NULL )))
554 {
555 ret = GetLastError();
556 CloseHandle( query->stop );
557
558 LeaveCriticalSection( &pdh_handle_cs );
559 return ret;
560 }
561
562 LeaveCriticalSection( &pdh_handle_cs );
563 return ERROR_SUCCESS;
564 }
565
566 /***********************************************************************
567 * PdhCollectQueryDataWithTime (PDH.@)
568 */
569 PDH_STATUS WINAPI PdhCollectQueryDataWithTime( PDH_HQUERY handle, LONGLONG *timestamp )
570 {
571 struct query *query = handle;
572 struct counter *counter;
573 struct list *item;
574
575 TRACE("%p %p\n", handle, timestamp);
576
577 if (!timestamp) return PDH_INVALID_ARGUMENT;
578
579 EnterCriticalSection( &pdh_handle_cs );
580 if (!query || query->magic != PDH_MAGIC_QUERY)
581 {
582 LeaveCriticalSection( &pdh_handle_cs );
583 return PDH_INVALID_HANDLE;
584 }
585 if (list_empty( &query->counters ))
586 {
587 LeaveCriticalSection( &pdh_handle_cs );
588 return PDH_NO_DATA;
589 }
590
591 collect_query_data( query );
592
593 item = list_head( &query->counters );
594 counter = LIST_ENTRY( item, struct counter, entry );
595
596 *timestamp = ((LONGLONG)counter->stamp.dwHighDateTime << 32) | counter->stamp.dwLowDateTime;
597
598 LeaveCriticalSection( &pdh_handle_cs );
599 return ERROR_SUCCESS;
600 }
601
602 /***********************************************************************
603 * PdhExpandWildCardPathA (PDH.@)
604 */
605 PDH_STATUS WINAPI PdhExpandWildCardPathA( LPCSTR szDataSource, LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags )
606 {
607 FIXME("%s, %s, %p, %p, 0x%x: stub\n", debugstr_a(szDataSource), debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
608 return PDH_NOT_IMPLEMENTED;
609 }
610
611 /***********************************************************************
612 * PdhExpandWildCardPathW (PDH.@)
613 */
614 PDH_STATUS WINAPI PdhExpandWildCardPathW( LPCWSTR szDataSource, LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags )
615 {
616 FIXME("%s, %s, %p, %p, 0x%x: stub\n", debugstr_w(szDataSource), debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
617 return PDH_NOT_IMPLEMENTED;
618 }
619
620 /***********************************************************************
621 * PdhGetCounterInfoA (PDH.@)
622 */
623 PDH_STATUS WINAPI PdhGetCounterInfoA( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_A info )
624 {
625 struct counter *counter = handle;
626
627 TRACE("%p %d %p %p\n", handle, text, size, info);
628
629 EnterCriticalSection( &pdh_handle_cs );
630 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
631 {
632 LeaveCriticalSection( &pdh_handle_cs );
633 return PDH_INVALID_HANDLE;
634 }
635 if (!size)
636 {
637 LeaveCriticalSection( &pdh_handle_cs );
638 return PDH_INVALID_ARGUMENT;
639 }
640 if (*size < sizeof(PDH_COUNTER_INFO_A))
641 {
642 *size = sizeof(PDH_COUNTER_INFO_A);
643 LeaveCriticalSection( &pdh_handle_cs );
644 return PDH_MORE_DATA;
645 }
646
647 memset( info, 0, sizeof(PDH_COUNTER_INFO_A) );
648
649 info->dwType = counter->type;
650 info->CStatus = counter->status;
651 info->lScale = counter->scale;
652 info->lDefaultScale = counter->defaultscale;
653 info->dwUserData = counter->user;
654 info->dwQueryUserData = counter->queryuser;
655
656 *size = sizeof(PDH_COUNTER_INFO_A);
657
658 LeaveCriticalSection( &pdh_handle_cs );
659 return ERROR_SUCCESS;
660 }
661
662 /***********************************************************************
663 * PdhGetCounterInfoW (PDH.@)
664 */
665 PDH_STATUS WINAPI PdhGetCounterInfoW( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_W info )
666 {
667 struct counter *counter = handle;
668
669 TRACE("%p %d %p %p\n", handle, text, size, info);
670
671 EnterCriticalSection( &pdh_handle_cs );
672 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
673 {
674 LeaveCriticalSection( &pdh_handle_cs );
675 return PDH_INVALID_HANDLE;
676 }
677 if (!size)
678 {
679 LeaveCriticalSection( &pdh_handle_cs );
680 return PDH_INVALID_ARGUMENT;
681 }
682 if (*size < sizeof(PDH_COUNTER_INFO_W))
683 {
684 *size = sizeof(PDH_COUNTER_INFO_W);
685 LeaveCriticalSection( &pdh_handle_cs );
686 return PDH_MORE_DATA;
687 }
688
689 memset( info, 0, sizeof(PDH_COUNTER_INFO_W) );
690
691 info->dwType = counter->type;
692 info->CStatus = counter->status;
693 info->lScale = counter->scale;
694 info->lDefaultScale = counter->defaultscale;
695 info->dwUserData = counter->user;
696 info->dwQueryUserData = counter->queryuser;
697
698 *size = sizeof(PDH_COUNTER_INFO_W);
699
700 LeaveCriticalSection( &pdh_handle_cs );
701 return ERROR_SUCCESS;
702 }
703
704 /***********************************************************************
705 * PdhGetCounterTimeBase (PDH.@)
706 */
707 PDH_STATUS WINAPI PdhGetCounterTimeBase( PDH_HCOUNTER handle, LONGLONG *base )
708 {
709 struct counter *counter = handle;
710
711 TRACE("%p %p\n", handle, base);
712
713 if (!base) return PDH_INVALID_ARGUMENT;
714
715 EnterCriticalSection( &pdh_handle_cs );
716 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
717 {
718 LeaveCriticalSection( &pdh_handle_cs );
719 return PDH_INVALID_HANDLE;
720 }
721
722 *base = counter->base;
723
724 LeaveCriticalSection( &pdh_handle_cs );
725 return ERROR_SUCCESS;
726 }
727
728 /***********************************************************************
729 * PdhGetDllVersion (PDH.@)
730 */
731 PDH_STATUS WINAPI PdhGetDllVersion( LPDWORD version )
732 {
733 if (!version)
734 return PDH_INVALID_ARGUMENT;
735
736 *version = PDH_VERSION;
737
738 return ERROR_SUCCESS;
739 }
740
741 /***********************************************************************
742 * PdhGetFormattedCounterValue (PDH.@)
743 */
744 PDH_STATUS WINAPI PdhGetFormattedCounterValue( PDH_HCOUNTER handle, DWORD format,
745 LPDWORD type, PPDH_FMT_COUNTERVALUE value )
746 {
747 PDH_STATUS ret;
748 struct counter *counter = handle;
749
750 TRACE("%p %x %p %p\n", handle, format, type, value);
751
752 if (!value) return PDH_INVALID_ARGUMENT;
753
754 EnterCriticalSection( &pdh_handle_cs );
755 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
756 {
757 LeaveCriticalSection( &pdh_handle_cs );
758 return PDH_INVALID_HANDLE;
759 }
760 if (counter->status)
761 {
762 LeaveCriticalSection( &pdh_handle_cs );
763 return PDH_INVALID_DATA;
764 }
765 if (!(ret = format_value( counter, format, &counter->one, &counter->two, value )))
766 {
767 value->CStatus = ERROR_SUCCESS;
768 if (type) *type = counter->type;
769 }
770
771 LeaveCriticalSection( &pdh_handle_cs );
772 return ret;
773 }
774
775 /***********************************************************************
776 * PdhGetRawCounterValue (PDH.@)
777 */
778 PDH_STATUS WINAPI PdhGetRawCounterValue( PDH_HCOUNTER handle, LPDWORD type,
779 PPDH_RAW_COUNTER value )
780 {
781 struct counter *counter = handle;
782
783 TRACE("%p %p %p\n", handle, type, value);
784
785 if (!value) return PDH_INVALID_ARGUMENT;
786
787 EnterCriticalSection( &pdh_handle_cs );
788 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
789 {
790 LeaveCriticalSection( &pdh_handle_cs );
791 return PDH_INVALID_HANDLE;
792 }
793
794 value->CStatus = counter->status;
795 value->TimeStamp.dwLowDateTime = counter->stamp.dwLowDateTime;
796 value->TimeStamp.dwHighDateTime = counter->stamp.dwHighDateTime;
797 value->FirstValue = counter->one.largevalue;
798 value->SecondValue = counter->two.largevalue;
799 value->MultiCount = 1; /* FIXME */
800
801 if (type) *type = counter->type;
802
803 LeaveCriticalSection( &pdh_handle_cs );
804 return ERROR_SUCCESS;
805 }
806
807 /***********************************************************************
808 * PdhLookupPerfIndexByNameA (PDH.@)
809 */
810 PDH_STATUS WINAPI PdhLookupPerfIndexByNameA( LPCSTR machine, LPCSTR name, LPDWORD index )
811 {
812 PDH_STATUS ret;
813 WCHAR *machineW = NULL;
814 WCHAR *nameW;
815
816 TRACE("%s %s %p\n", debugstr_a(machine), debugstr_a(name), index);
817
818 if (!name) return PDH_INVALID_ARGUMENT;
819
820 if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
821
822 if (!(nameW = pdh_strdup_aw( name )))
823 return PDH_MEMORY_ALLOCATION_FAILURE;
824
825 ret = PdhLookupPerfIndexByNameW( machineW, nameW, index );
826
827 heap_free( nameW );
828 heap_free( machineW );
829 return ret;
830 }
831
832 /***********************************************************************
833 * PdhLookupPerfIndexByNameW (PDH.@)
834 */
835 PDH_STATUS WINAPI PdhLookupPerfIndexByNameW( LPCWSTR machine, LPCWSTR name, LPDWORD index )
836 {
837 unsigned int i;
838
839 TRACE("%s %s %p\n", debugstr_w(machine), debugstr_w(name), index);
840
841 if (!name || !index) return PDH_INVALID_ARGUMENT;
842
843 if (machine)
844 {
845 FIXME("remote machine not supported\n");
846 return PDH_CSTATUS_NO_MACHINE;
847 }
848 for (i = 0; i < sizeof(counter_sources) / sizeof(counter_sources[0]); i++)
849 {
850 if (pdh_match_path( counter_sources[i].path, name ))
851 {
852 *index = counter_sources[i].index;
853 return ERROR_SUCCESS;
854 }
855 }
856 return PDH_STRING_NOT_FOUND;
857 }
858
859 /***********************************************************************
860 * PdhLookupPerfNameByIndexA (PDH.@)
861 */
862 PDH_STATUS WINAPI PdhLookupPerfNameByIndexA( LPCSTR machine, DWORD index, LPSTR buffer, LPDWORD size )
863 {
864 PDH_STATUS ret;
865 WCHAR *machineW = NULL;
866 WCHAR bufferW[PDH_MAX_COUNTER_NAME];
867 DWORD sizeW = sizeof(bufferW) / sizeof(WCHAR);
868
869 TRACE("%s %d %p %p\n", debugstr_a(machine), index, buffer, size);
870
871 if (!buffer || !size) return PDH_INVALID_ARGUMENT;
872
873 if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
874
875 if (!(ret = PdhLookupPerfNameByIndexW( machineW, index, bufferW, &sizeW )))
876 {
877 int required = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
878
879 if (size && *size < required) ret = PDH_MORE_DATA;
880 else WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, required, NULL, NULL );
881 if (size) *size = required;
882 }
883 heap_free( machineW );
884 return ret;
885 }
886
887 /***********************************************************************
888 * PdhLookupPerfNameByIndexW (PDH.@)
889 */
890 PDH_STATUS WINAPI PdhLookupPerfNameByIndexW( LPCWSTR machine, DWORD index, LPWSTR buffer, LPDWORD size )
891 {
892 PDH_STATUS ret;
893 unsigned int i;
894
895 TRACE("%s %d %p %p\n", debugstr_w(machine), index, buffer, size);
896
897 if (machine)
898 {
899 FIXME("remote machine not supported\n");
900 return PDH_CSTATUS_NO_MACHINE;
901 }
902
903 if (!buffer || !size) return PDH_INVALID_ARGUMENT;
904 if (!index) return ERROR_SUCCESS;
905
906 for (i = 0; i < sizeof(counter_sources) / sizeof(counter_sources[0]); i++)
907 {
908 if (counter_sources[i].index == index)
909 {
910 WCHAR *p = strrchrW( counter_sources[i].path, '\\' ) + 1;
911 unsigned int required = strlenW( p ) + 1;
912
913 if (*size < required) ret = PDH_MORE_DATA;
914 else
915 {
916 strcpyW( buffer, p );
917 ret = ERROR_SUCCESS;
918 }
919 *size = required;
920 return ret;
921 }
922 }
923 return PDH_INVALID_ARGUMENT;
924 }
925
926 /***********************************************************************
927 * PdhOpenQueryA (PDH.@)
928 */
929 PDH_STATUS WINAPI PdhOpenQueryA( LPCSTR source, DWORD_PTR userdata, PDH_HQUERY *query )
930 {
931 PDH_STATUS ret;
932 WCHAR *sourceW = NULL;
933
934 TRACE("%s %lx %p\n", debugstr_a(source), userdata, query);
935
936 if (source && !(sourceW = pdh_strdup_aw( source ))) return PDH_MEMORY_ALLOCATION_FAILURE;
937
938 ret = PdhOpenQueryW( sourceW, userdata, query );
939 heap_free( sourceW );
940
941 return ret;
942 }
943
944 /***********************************************************************
945 * PdhOpenQueryW (PDH.@)
946 */
947 PDH_STATUS WINAPI PdhOpenQueryW( LPCWSTR source, DWORD_PTR userdata, PDH_HQUERY *handle )
948 {
949 struct query *query;
950
951 TRACE("%s %lx %p\n", debugstr_w(source), userdata, handle);
952
953 if (!handle) return PDH_INVALID_ARGUMENT;
954
955 if (source)
956 {
957 FIXME("log file data source not supported\n");
958 return PDH_INVALID_ARGUMENT;
959 }
960 if ((query = create_query()))
961 {
962 query->user = userdata;
963 *handle = query;
964
965 return ERROR_SUCCESS;
966 }
967 return PDH_MEMORY_ALLOCATION_FAILURE;
968 }
969
970 /***********************************************************************
971 * PdhRemoveCounter (PDH.@)
972 */
973 PDH_STATUS WINAPI PdhRemoveCounter( PDH_HCOUNTER handle )
974 {
975 struct counter *counter = handle;
976
977 TRACE("%p\n", handle);
978
979 EnterCriticalSection( &pdh_handle_cs );
980 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
981 {
982 LeaveCriticalSection( &pdh_handle_cs );
983 return PDH_INVALID_HANDLE;
984 }
985
986 list_remove( &counter->entry );
987 destroy_counter( counter );
988
989 LeaveCriticalSection( &pdh_handle_cs );
990 return ERROR_SUCCESS;
991 }
992
993 /***********************************************************************
994 * PdhSetCounterScaleFactor (PDH.@)
995 */
996 PDH_STATUS WINAPI PdhSetCounterScaleFactor( PDH_HCOUNTER handle, LONG factor )
997 {
998 struct counter *counter = handle;
999
1000 TRACE("%p\n", handle);
1001
1002 EnterCriticalSection( &pdh_handle_cs );
1003 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
1004 {
1005 LeaveCriticalSection( &pdh_handle_cs );
1006 return PDH_INVALID_HANDLE;
1007 }
1008 if (factor < PDH_MIN_SCALE || factor > PDH_MAX_SCALE)
1009 {
1010 LeaveCriticalSection( &pdh_handle_cs );
1011 return PDH_INVALID_ARGUMENT;
1012 }
1013
1014 counter->scale = factor;
1015
1016 LeaveCriticalSection( &pdh_handle_cs );
1017 return ERROR_SUCCESS;
1018 }
1019
1020 /***********************************************************************
1021 * PdhValidatePathA (PDH.@)
1022 */
1023 PDH_STATUS WINAPI PdhValidatePathA( LPCSTR path )
1024 {
1025 PDH_STATUS ret;
1026 WCHAR *pathW;
1027
1028 TRACE("%s\n", debugstr_a(path));
1029
1030 if (!path) return PDH_INVALID_ARGUMENT;
1031 if (!(pathW = pdh_strdup_aw( path ))) return PDH_MEMORY_ALLOCATION_FAILURE;
1032
1033 ret = PdhValidatePathW( pathW );
1034
1035 heap_free( pathW );
1036 return ret;
1037 }
1038
1039 static PDH_STATUS validate_path( LPCWSTR path )
1040 {
1041 if (!path || !*path) return PDH_INVALID_ARGUMENT;
1042 if (*path++ != '\\' || !strchrW( path, '\\' )) return PDH_CSTATUS_BAD_COUNTERNAME;
1043 return ERROR_SUCCESS;
1044 }
1045
1046 /***********************************************************************
1047 * PdhValidatePathW (PDH.@)
1048 */
1049 PDH_STATUS WINAPI PdhValidatePathW( LPCWSTR path )
1050 {
1051 PDH_STATUS ret;
1052 unsigned int i;
1053
1054 TRACE("%s\n", debugstr_w(path));
1055
1056 if ((ret = validate_path( path ))) return ret;
1057
1058 for (i = 0; i < sizeof(counter_sources) / sizeof(counter_sources[0]); i++)
1059 if (pdh_match_path( counter_sources[i].path, path )) return ERROR_SUCCESS;
1060
1061 return PDH_CSTATUS_NO_COUNTER;
1062 }
1063
1064 /***********************************************************************
1065 * PdhValidatePathExA (PDH.@)
1066 */
1067 PDH_STATUS WINAPI PdhValidatePathExA( PDH_HLOG source, LPCSTR path )
1068 {
1069 TRACE("%p %s\n", source, debugstr_a(path));
1070
1071 if (source)
1072 {
1073 FIXME("log file data source not supported\n");
1074 return ERROR_SUCCESS;
1075 }
1076 return PdhValidatePathA( path );
1077 }
1078
1079 /***********************************************************************
1080 * PdhValidatePathExW (PDH.@)
1081 */
1082 PDH_STATUS WINAPI PdhValidatePathExW( PDH_HLOG source, LPCWSTR path )
1083 {
1084 TRACE("%p %s\n", source, debugstr_w(path));
1085
1086 if (source)
1087 {
1088 FIXME("log file data source not supported\n");
1089 return ERROR_SUCCESS;
1090 }
1091 return PdhValidatePathW( path );
1092 }
1093
1094 /***********************************************************************
1095 * PdhMakeCounterPathA (PDH.@)
1096 */
1097 PDH_STATUS WINAPI PdhMakeCounterPathA( PDH_COUNTER_PATH_ELEMENTS_A *e, LPSTR buffer,
1098 LPDWORD buflen, DWORD flags )
1099 {
1100 PDH_STATUS ret = PDH_MEMORY_ALLOCATION_FAILURE;
1101 PDH_COUNTER_PATH_ELEMENTS_W eW;
1102 WCHAR *bufferW;
1103 DWORD buflenW;
1104
1105 TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);
1106
1107 if (!e || !buflen) return PDH_INVALID_ARGUMENT;
1108
1109 memset( &eW, 0, sizeof(eW) );
1110 if (e->szMachineName && !(eW.szMachineName = pdh_strdup_aw( e->szMachineName ))) goto done;
1111 if (e->szObjectName && !(eW.szObjectName = pdh_strdup_aw( e->szObjectName ))) goto done;
1112 if (e->szInstanceName && !(eW.szInstanceName = pdh_strdup_aw( e->szInstanceName ))) goto done;
1113 if (e->szParentInstance && !(eW.szParentInstance = pdh_strdup_aw( e->szParentInstance ))) goto done;
1114 if (e->szCounterName && !(eW.szCounterName = pdh_strdup_aw( e->szCounterName ))) goto done;
1115 eW.dwInstanceIndex = e->dwInstanceIndex;
1116
1117 buflenW = 0;
1118 ret = PdhMakeCounterPathW( &eW, NULL, &buflenW, flags );
1119 if (ret == PDH_MORE_DATA)
1120 {
1121 if ((bufferW = heap_alloc( buflenW * sizeof(WCHAR) )))
1122 {
1123 if (!(ret = PdhMakeCounterPathW( &eW, bufferW, &buflenW, flags )))
1124 {
1125 int len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
1126 if (*buflen >= len) WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, *buflen, NULL, NULL);
1127 else ret = PDH_MORE_DATA;
1128 *buflen = len;
1129 }
1130 heap_free( bufferW );
1131 }
1132 else
1133 ret = PDH_MEMORY_ALLOCATION_FAILURE;
1134 }
1135
1136 done:
1137 heap_free( eW.szMachineName );
1138 heap_free( eW.szObjectName );
1139 heap_free( eW.szInstanceName );
1140 heap_free( eW.szParentInstance );
1141 heap_free( eW.szCounterName );
1142 return ret;
1143 }
1144
1145 /***********************************************************************
1146 * PdhMakeCounterPathW (PDH.@)
1147 */
1148 PDH_STATUS WINAPI PdhMakeCounterPathW( PDH_COUNTER_PATH_ELEMENTS_W *e, LPWSTR buffer,
1149 LPDWORD buflen, DWORD flags )
1150 {
1151 static const WCHAR bslash[] = {'\\',0};
1152 static const WCHAR fslash[] = {'/',0};
1153 static const WCHAR lparen[] = {'(',0};
1154 static const WCHAR rparen[] = {')',0};
1155 static const WCHAR fmt[] = {'#','%','u',0};
1156
1157 WCHAR path[PDH_MAX_COUNTER_NAME], instance[12];
1158 PDH_STATUS ret = ERROR_SUCCESS;
1159 DWORD len;
1160
1161 TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);
1162
1163 if (flags) FIXME("unimplemented flags 0x%08x\n", flags);
1164
1165 if (!e || !e->szCounterName || !e->szObjectName || !buflen)
1166 return PDH_INVALID_ARGUMENT;
1167
1168 path[0] = 0;
1169 if (e->szMachineName)
1170 {
1171 strcatW(path, bslash);
1172 strcatW(path, bslash);
1173 strcatW(path, e->szMachineName);
1174 }
1175 strcatW(path, bslash);
1176 strcatW(path, e->szObjectName);
1177 if (e->szInstanceName)
1178 {
1179 strcatW(path, lparen);
1180 if (e->szParentInstance)
1181 {
1182 strcatW(path, e->szParentInstance);
1183 strcatW(path, fslash);
1184 }
1185 strcatW(path, e->szInstanceName);
1186 sprintfW(instance, fmt, e->dwInstanceIndex);
1187 strcatW(path, instance);
1188 strcatW(path, rparen);
1189 }
1190 strcatW(path, bslash);
1191 strcatW(path, e->szCounterName);
1192
1193 len = strlenW(path) + 1;
1194 if (*buflen >= len) strcpyW(buffer, path);
1195 else ret = PDH_MORE_DATA;
1196 *buflen = len;
1197 return ret;
1198 }
1199
1200 /***********************************************************************
1201 * PdhEnumObjectItemsA (PDH.@)
1202 */
1203 PDH_STATUS WINAPI PdhEnumObjectItemsA(LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName,
1204 LPSTR mszCounterList, LPDWORD pcchCounterListLength, LPSTR mszInstanceList,
1205 LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
1206 {
1207 FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_a(szDataSource), debugstr_a(szMachineName),
1208 debugstr_a(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
1209 pcchInstanceListLength, dwDetailLevel, dwFlags);
1210
1211 return PDH_NOT_IMPLEMENTED;
1212 }
1213
1214 /***********************************************************************
1215 * PdhEnumObjectItemsW (PDH.@)
1216 */
1217 PDH_STATUS WINAPI PdhEnumObjectItemsW(LPCWSTR szDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName,
1218 LPWSTR mszCounterList, LPDWORD pcchCounterListLength, LPWSTR mszInstanceList,
1219 LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
1220 {
1221 FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: stub\n", debugstr_w(szDataSource), debugstr_w(szMachineName),
1222 debugstr_w(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
1223 pcchInstanceListLength, dwDetailLevel, dwFlags);
1224
1225 return PDH_NOT_IMPLEMENTED;
1226 }
1227
1228 /***********************************************************************
1229 * PdhSetDefaultRealTimeDataSource (PDH.@)
1230 */
1231 PDH_STATUS WINAPI PdhSetDefaultRealTimeDataSource( DWORD source )
1232 {
1233 FIXME("%u\n", source);
1234 return ERROR_SUCCESS;
1235 }