projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[PDH] Sync with Wine Staging 4.18. CORE-16441
[reactos.git] / 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
27 #include "windef.h"
28 #include "winbase.h"
29
30 #include "pdh.h"
31 #include "pdhmsg.h"
32 #include "winperf.h"
33 #ifdef __REACTOS__
34 #include <wchar.h>
35 #include <winnls.h>
36 #endif
37
38 #include "wine/debug.h"
39 #include "wine/heap.h"
40 #include "wine/list.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(pdh);
43
44 static CRITICAL_SECTION pdh_handle_cs;
45 static CRITICAL_SECTION_DEBUG pdh_handle_cs_debug =
46 {
47 0, 0, &pdh_handle_cs,
48 { &pdh_handle_cs_debug.ProcessLocksList,
49 &pdh_handle_cs_debug.ProcessLocksList },
50 0, 0, { (DWORD_PTR)(__FILE__ ": pdh_handle_cs") }
51 };
52 static CRITICAL_SECTION pdh_handle_cs = { &pdh_handle_cs_debug, -1, 0, 0, 0, 0 };
53
54 static inline WCHAR *pdh_strdup( const WCHAR *src )
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 }
62
63 static inline WCHAR *pdh_strdup_aw( const char *src )
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 }
73
74 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
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 */
81 case DLL_PROCESS_ATTACH:
82 DisableThreadLibraryCalls(hinstDLL);
83 break;
84 case DLL_PROCESS_DETACH:
85 if (lpvReserved) break;
86 DeleteCriticalSection(&pdh_handle_cs);
87 break;
88 }
89
90 return TRUE;
91 }
92
93 union value
94 {
95 LONG longvalue;
96 double doublevalue;
97 LONGLONG largevalue;
98 };
99
100 struct counter
101 {
102 DWORD magic; /* signature */
103 struct list entry; /* list entry */
104 WCHAR *path; /* identifier */
105 DWORD type; /* counter type */
106 DWORD status; /* update status */
107 LONG scale; /* scale factor */
108 LONG defaultscale; /* default scale factor */
109 DWORD_PTR user; /* user data */
110 DWORD_PTR queryuser; /* query user data */
111 LONGLONG base; /* samples per second */
112 FILETIME stamp; /* time stamp */
113 void (CALLBACK *collect)( struct counter * ); /* collect callback */
114 union value one; /* first value */
115 union value two; /* second value */
116 };
117
118 #define PDH_MAGIC_COUNTER 0x50444831 /* 'PDH1' */
119
120 static struct counter *create_counter( void )
121 {
122 struct counter *counter;
123
124 if ((counter = heap_alloc_zero( sizeof(struct counter) )))
125 {
126 counter->magic = PDH_MAGIC_COUNTER;
127 return counter;
128 }
129 return NULL;
130 }
131
132 static void destroy_counter( struct counter *counter )
133 {
134 counter->magic = 0;
135 heap_free( counter->path );
136 heap_free( counter );
137 }
138
139 #define PDH_MAGIC_QUERY 0x50444830 /* 'PDH0' */
140
141 struct query
142 {
143 DWORD magic; /* signature */
144 DWORD_PTR user; /* user data */
145 HANDLE thread; /* collect thread */
146 DWORD interval; /* collect interval */
147 HANDLE wait; /* wait event */
148 HANDLE stop; /* stop event */
149 struct list counters; /* counter list */
150 };
151
152 static struct query *create_query( void )
153 {
154 struct query *query;
155
156 if ((query = heap_alloc_zero( sizeof(struct query) )))
157 {
158 query->magic = PDH_MAGIC_QUERY;
159 list_init( &query->counters );
160 return query;
161 }
162 return NULL;
163 }
164
165 static void destroy_query( struct query *query )
166 {
167 query->magic = 0;
168 heap_free( query );
169 }
170
171 struct source
172 {
173 DWORD index; /* name index */
174 const WCHAR *path; /* identifier */
175 void (CALLBACK *collect)( struct counter * ); /* collect callback */
176 DWORD type; /* counter type */
177 LONG scale; /* default scale factor */
178 LONGLONG base; /* samples per second */
179 };
180
181 static const WCHAR path_processor_time[] =
182 {'\\','P','r','o','c','e','s','s','o','r','(','_','T','o','t','a','l',')',
183 '\\','%',' ','P','r','o','c','e','s','s','o','r',' ','T','i','m','e',0};
184 static const WCHAR path_processor[] =
185 {'\\','P','r','o','c','e','s','s','o','r',0};
186 static const WCHAR path_uptime[] =
187 {'\\','S','y','s','t','e','m', '\\', 'S','y','s','t','e','m',' ','U','p',' ','T','i','m','e',0};
188
189 static void CALLBACK collect_processor_time( struct counter *counter )
190 {
191 counter->two.largevalue = 500000; /* FIXME */
192 counter->status = PDH_CSTATUS_VALID_DATA;
193 }
194
195 static void CALLBACK collect_uptime( struct counter *counter )
196 {
197 counter->two.largevalue = GetTickCount64();
198 counter->status = PDH_CSTATUS_VALID_DATA;
199 }
200
201 #define TYPE_PROCESSOR_TIME \
202 (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | \
203 PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)
204
205 #define TYPE_UPTIME \
206 (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)
207
208 /* counter source registry */
209 static const struct source counter_sources[] =
210 {
211 { 6, path_processor_time, collect_processor_time, TYPE_PROCESSOR_TIME, -5, 10000000 },
212 { 238, path_processor, NULL, 0, 0, 0 },
213 { 674, path_uptime, collect_uptime, TYPE_UPTIME, -3, 1000 }
214 };
215
216 static BOOL is_local_machine( const WCHAR *name, DWORD len )
217 {
218 WCHAR buf[MAX_COMPUTERNAME_LENGTH + 1];
219 DWORD buflen = ARRAY_SIZE(buf);
220
221 if (!GetComputerNameW( buf, &buflen )) return FALSE;
222 return len == buflen && !_wcsnicmp( name, buf, buflen );
223 }
224
225 static BOOL pdh_match_path( LPCWSTR fullpath, LPCWSTR path )
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 }
238
239 /***********************************************************************
240 * PdhAddCounterA (PDH.@)
241 */
242 PDH_STATUS WINAPI PdhAddCounterA( PDH_HQUERY query, LPCSTR path,
243 DWORD_PTR userdata, PDH_HCOUNTER *counter )
244 {
245 PDH_STATUS ret;
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 )))
253 return PDH_MEMORY_ALLOCATION_FAILURE;
254
255 ret = PdhAddCounterW( query, pathW, userdata, counter );
256
257 heap_free( pathW );
258 return ret;
259 }
260
261 /***********************************************************************
262 * PdhAddCounterW (PDH.@)
263 */
264 PDH_STATUS WINAPI PdhAddCounterW( PDH_HQUERY hquery, LPCWSTR path,
265 DWORD_PTR userdata, PDH_HCOUNTER *hcounter )
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
275 EnterCriticalSection( &pdh_handle_cs );
276 if (!query || query->magic != PDH_MAGIC_QUERY)
277 {
278 LeaveCriticalSection( &pdh_handle_cs );
279 return PDH_INVALID_HANDLE;
280 }
281
282 *hcounter = NULL;
283 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
284 {
285 if (pdh_match_path( counter_sources[i].path, path ))
286 {
287 if ((counter = create_counter()))
288 {
289 counter->path = pdh_strdup( counter_sources[i].path );
290 counter->collect = counter_sources[i].collect;
291 counter->type = counter_sources[i].type;
292 counter->defaultscale = counter_sources[i].scale;
293 counter->base = counter_sources[i].base;
294 counter->queryuser = query->user;
295 counter->user = userdata;
296
297 list_add_tail( &query->counters, &counter->entry );
298 *hcounter = counter;
299
300 LeaveCriticalSection( &pdh_handle_cs );
301 return ERROR_SUCCESS;
302 }
303 LeaveCriticalSection( &pdh_handle_cs );
304 return PDH_MEMORY_ALLOCATION_FAILURE;
305 }
306 }
307 LeaveCriticalSection( &pdh_handle_cs );
308 return PDH_CSTATUS_NO_COUNTER;
309 }
310
311 /***********************************************************************
312 * PdhAddEnglishCounterA (PDH.@)
313 */
314 PDH_STATUS WINAPI PdhAddEnglishCounterA( PDH_HQUERY query, LPCSTR path,
315 DWORD_PTR userdata, PDH_HCOUNTER *counter )
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 }
322
323 /***********************************************************************
324 * PdhAddEnglishCounterW (PDH.@)
325 */
326 PDH_STATUS WINAPI PdhAddEnglishCounterW( PDH_HQUERY query, LPCWSTR path,
327 DWORD_PTR userdata, PDH_HCOUNTER *counter )
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 }
334
335 /* caller must hold counter lock */
336 static PDH_STATUS format_value( struct counter *counter, DWORD format, union value *raw1,
337 union value *raw2, PDH_FMT_COUNTERVALUE *value )
338 {
339 LONG factor;
340
341 factor = counter->scale ? counter->scale : counter->defaultscale;
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);
360 return PDH_INVALID_ARGUMENT;
361 }
362 return ERROR_SUCCESS;
363 }
364
365 /***********************************************************************
366 * PdhCalculateCounterFromRawValue (PDH.@)
367 */
368 PDH_STATUS WINAPI PdhCalculateCounterFromRawValue( PDH_HCOUNTER handle, DWORD format,
369 PPDH_RAW_COUNTER raw1, PPDH_RAW_COUNTER raw2,
370 PPDH_FMT_COUNTERVALUE value )
371 {
372 PDH_STATUS ret;
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
379 EnterCriticalSection( &pdh_handle_cs );
380 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
381 {
382 LeaveCriticalSection( &pdh_handle_cs );
383 return PDH_INVALID_HANDLE;
384 }
385
386 ret = format_value( counter, format, (union value *)&raw1->SecondValue,
387 (union value *)&raw2->SecondValue, value );
388
389 LeaveCriticalSection( &pdh_handle_cs );
390 return ret;
391 }
392
393
394 /***********************************************************************
395 * PdhCloseQuery (PDH.@)
396 */
397 PDH_STATUS WINAPI PdhCloseQuery( PDH_HQUERY handle )
398 {
399 struct query *query = handle;
400 struct list *item, *next;
401
402 TRACE("%p\n", handle);
403
404 EnterCriticalSection( &pdh_handle_cs );
405 if (!query || query->magic != PDH_MAGIC_QUERY)
406 {
407 LeaveCriticalSection( &pdh_handle_cs );
408 return PDH_INVALID_HANDLE;
409 }
410
411 if (query->thread)
412 {
413 HANDLE thread = query->thread;
414 SetEvent( query->stop );
415 LeaveCriticalSection( &pdh_handle_cs );
416
417 WaitForSingleObject( thread, INFINITE );
418
419 EnterCriticalSection( &pdh_handle_cs );
420 if (query->magic != PDH_MAGIC_QUERY)
421 {
422 LeaveCriticalSection( &pdh_handle_cs );
423 return ERROR_SUCCESS;
424 }
425 CloseHandle( query->stop );
426 CloseHandle( query->thread );
427 query->thread = NULL;
428 }
429
430 LIST_FOR_EACH_SAFE( item, next, &query->counters )
431 {
432 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
433
434 list_remove( &counter->entry );
435 destroy_counter( counter );
436 }
437
438 destroy_query( query );
439
440 LeaveCriticalSection( &pdh_handle_cs );
441 return ERROR_SUCCESS;
442 }
443
444 /* caller must hold query lock */
445 static void collect_query_data( struct query *query )
446 {
447 struct list *item;
448
449 LIST_FOR_EACH( item, &query->counters )
450 {
451 SYSTEMTIME time;
452 struct counter *counter = LIST_ENTRY( item, struct counter, entry );
453
454 counter->collect( counter );
455
456 GetLocalTime( &time );
457 SystemTimeToFileTime( &time, &counter->stamp );
458 }
459 }
460
461 /***********************************************************************
462 * PdhCollectQueryData (PDH.@)
463 */
464 PDH_STATUS WINAPI PdhCollectQueryData( PDH_HQUERY handle )
465 {
466 struct query *query = handle;
467
468 TRACE("%p\n", handle);
469
470 EnterCriticalSection( &pdh_handle_cs );
471 if (!query || query->magic != PDH_MAGIC_QUERY)
472 {
473 LeaveCriticalSection( &pdh_handle_cs );
474 return PDH_INVALID_HANDLE;
475 }
476
477 if (list_empty( &query->counters ))
478 {
479 LeaveCriticalSection( &pdh_handle_cs );
480 return PDH_NO_DATA;
481 }
482
483 collect_query_data( query );
484
485 LeaveCriticalSection( &pdh_handle_cs );
486 return ERROR_SUCCESS;
487 }
488
489 static DWORD CALLBACK collect_query_thread( void *arg )
490 {
491 struct query *query = arg;
492 DWORD interval = query->interval;
493 HANDLE stop = query->stop;
494
495 for (;;)
496 {
497 if (WaitForSingleObject( stop, interval ) != WAIT_TIMEOUT) ExitThread( 0 );
498
499 EnterCriticalSection( &pdh_handle_cs );
500 if (query->magic != PDH_MAGIC_QUERY)
501 {
502 LeaveCriticalSection( &pdh_handle_cs );
503 ExitThread( PDH_INVALID_HANDLE );
504 }
505
506 collect_query_data( query );
507
508 if (!SetEvent( query->wait ))
509 {
510 LeaveCriticalSection( &pdh_handle_cs );
511 ExitThread( 0 );
512 }
513 LeaveCriticalSection( &pdh_handle_cs );
514 }
515 }
516
517 /***********************************************************************
518 * PdhCollectQueryDataEx (PDH.@)
519 */
520 PDH_STATUS WINAPI PdhCollectQueryDataEx( PDH_HQUERY handle, DWORD interval, HANDLE event )
521 {
522 PDH_STATUS ret;
523 struct query *query = handle;
524
525 TRACE("%p %d %p\n", handle, interval, event);
526
527 EnterCriticalSection( &pdh_handle_cs );
528 if (!query || query->magic != PDH_MAGIC_QUERY)
529 {
530 LeaveCriticalSection( &pdh_handle_cs );
531 return PDH_INVALID_HANDLE;
532 }
533 if (list_empty( &query->counters ))
534 {
535 LeaveCriticalSection( &pdh_handle_cs );
536 return PDH_NO_DATA;
537 }
538 if (query->thread)
539 {
540 HANDLE thread = query->thread;
541 SetEvent( query->stop );
542 LeaveCriticalSection( &pdh_handle_cs );
543
544 WaitForSingleObject( thread, INFINITE );
545
546 EnterCriticalSection( &pdh_handle_cs );
547 if (query->magic != PDH_MAGIC_QUERY)
548 {
549 LeaveCriticalSection( &pdh_handle_cs );
550 return PDH_INVALID_HANDLE;
551 }
552 CloseHandle( query->thread );
553 query->thread = NULL;
554 }
555 else if (!(query->stop = CreateEventW( NULL, FALSE, FALSE, NULL )))
556 {
557 ret = GetLastError();
558 LeaveCriticalSection( &pdh_handle_cs );
559 return ret;
560 }
561 query->wait = event;
562 query->interval = interval * 1000;
563 if (!(query->thread = CreateThread( NULL, 0, collect_query_thread, query, 0, NULL )))
564 {
565 ret = GetLastError();
566 CloseHandle( query->stop );
567
568 LeaveCriticalSection( &pdh_handle_cs );
569 return ret;
570 }
571
572 LeaveCriticalSection( &pdh_handle_cs );
573 return ERROR_SUCCESS;
574 }
575
576 /***********************************************************************
577 * PdhCollectQueryDataWithTime (PDH.@)
578 */
579 PDH_STATUS WINAPI PdhCollectQueryDataWithTime( PDH_HQUERY handle, LONGLONG *timestamp )
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
589 EnterCriticalSection( &pdh_handle_cs );
590 if (!query || query->magic != PDH_MAGIC_QUERY)
591 {
592 LeaveCriticalSection( &pdh_handle_cs );
593 return PDH_INVALID_HANDLE;
594 }
595 if (list_empty( &query->counters ))
596 {
597 LeaveCriticalSection( &pdh_handle_cs );
598 return PDH_NO_DATA;
599 }
600
601 collect_query_data( query );
602
603 item = list_head( &query->counters );
604 counter = LIST_ENTRY( item, struct counter, entry );
605
606 *timestamp = ((LONGLONG)counter->stamp.dwHighDateTime << 32) | counter->stamp.dwLowDateTime;
607
608 LeaveCriticalSection( &pdh_handle_cs );
609 return ERROR_SUCCESS;
610 }
611
612 /***********************************************************************
613 * PdhExpandWildCardPathA (PDH.@)
614 */
615 PDH_STATUS WINAPI PdhExpandWildCardPathA( LPCSTR szDataSource, LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags )
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 }
620
621 /***********************************************************************
622 * PdhExpandWildCardPathW (PDH.@)
623 */
624 PDH_STATUS WINAPI PdhExpandWildCardPathW( LPCWSTR szDataSource, LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags )
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 }
629
630 /***********************************************************************
631 * PdhExpandCounterPathA (PDH.@)
632 */
633 PDH_STATUS WINAPI PdhExpandCounterPathA( LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength )
634 {
635 FIXME("%s, %p, %p: stub\n", debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength);
636 return PdhExpandWildCardPathA(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
637 }
638
639 /***********************************************************************
640 * PdhExpandCounterPathW (PDH.@)
641 */
642 PDH_STATUS WINAPI PdhExpandCounterPathW( LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength )
643 {
644 FIXME("%s, %p, %p: stub\n", debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength);
645 return PdhExpandWildCardPathW(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
646 }
647
648 /***********************************************************************
649 * PdhGetCounterInfoA (PDH.@)
650 */
651 PDH_STATUS WINAPI PdhGetCounterInfoA( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_A info )
652 {
653 struct counter *counter = handle;
654
655 TRACE("%p %d %p %p\n", handle, text, size, info);
656
657 EnterCriticalSection( &pdh_handle_cs );
658 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
659 {
660 LeaveCriticalSection( &pdh_handle_cs );
661 return PDH_INVALID_HANDLE;
662 }
663 if (!size)
664 {
665 LeaveCriticalSection( &pdh_handle_cs );
666 return PDH_INVALID_ARGUMENT;
667 }
668 if (*size < sizeof(PDH_COUNTER_INFO_A))
669 {
670 *size = sizeof(PDH_COUNTER_INFO_A);
671 LeaveCriticalSection( &pdh_handle_cs );
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
686 LeaveCriticalSection( &pdh_handle_cs );
687 return ERROR_SUCCESS;
688 }
689
690 /***********************************************************************
691 * PdhGetCounterInfoW (PDH.@)
692 */
693 PDH_STATUS WINAPI PdhGetCounterInfoW( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_W info )
694 {
695 struct counter *counter = handle;
696
697 TRACE("%p %d %p %p\n", handle, text, size, info);
698
699 EnterCriticalSection( &pdh_handle_cs );
700 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
701 {
702 LeaveCriticalSection( &pdh_handle_cs );
703 return PDH_INVALID_HANDLE;
704 }
705 if (!size)
706 {
707 LeaveCriticalSection( &pdh_handle_cs );
708 return PDH_INVALID_ARGUMENT;
709 }
710 if (*size < sizeof(PDH_COUNTER_INFO_W))
711 {
712 *size = sizeof(PDH_COUNTER_INFO_W);
713 LeaveCriticalSection( &pdh_handle_cs );
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
728 LeaveCriticalSection( &pdh_handle_cs );
729 return ERROR_SUCCESS;
730 }
731
732 /***********************************************************************
733 * PdhGetCounterTimeBase (PDH.@)
734 */
735 PDH_STATUS WINAPI PdhGetCounterTimeBase( PDH_HCOUNTER handle, LONGLONG *base )
736 {
737 struct counter *counter = handle;
738
739 TRACE("%p %p\n", handle, base);
740
741 if (!base) return PDH_INVALID_ARGUMENT;
742
743 EnterCriticalSection( &pdh_handle_cs );
744 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
745 {
746 LeaveCriticalSection( &pdh_handle_cs );
747 return PDH_INVALID_HANDLE;
748 }
749
750 *base = counter->base;
751
752 LeaveCriticalSection( &pdh_handle_cs );
753 return ERROR_SUCCESS;
754 }
755
756 /***********************************************************************
757 * PdhGetDllVersion (PDH.@)
758 */
759 PDH_STATUS WINAPI PdhGetDllVersion( LPDWORD version )
760 {
761 if (!version)
762 return PDH_INVALID_ARGUMENT;
763
764 *version = PDH_VERSION;
765
766 return ERROR_SUCCESS;
767 }
768
769 /***********************************************************************
770 * PdhGetFormattedCounterValue (PDH.@)
771 */
772 PDH_STATUS WINAPI PdhGetFormattedCounterValue( PDH_HCOUNTER handle, DWORD format,
773 LPDWORD type, PPDH_FMT_COUNTERVALUE value )
774 {
775 PDH_STATUS ret;
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
782 EnterCriticalSection( &pdh_handle_cs );
783 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
784 {
785 LeaveCriticalSection( &pdh_handle_cs );
786 return PDH_INVALID_HANDLE;
787 }
788 if (counter->status)
789 {
790 LeaveCriticalSection( &pdh_handle_cs );
791 return PDH_INVALID_DATA;
792 }
793 if (!(ret = format_value( counter, format, &counter->one, &counter->two, value )))
794 {
795 value->CStatus = ERROR_SUCCESS;
796 if (type) *type = counter->type;
797 }
798
799 LeaveCriticalSection( &pdh_handle_cs );
800 return ret;
801 }
802
803 /***********************************************************************
804 * PdhGetRawCounterValue (PDH.@)
805 */
806 PDH_STATUS WINAPI PdhGetRawCounterValue( PDH_HCOUNTER handle, LPDWORD type,
807 PPDH_RAW_COUNTER value )
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
815 EnterCriticalSection( &pdh_handle_cs );
816 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
817 {
818 LeaveCriticalSection( &pdh_handle_cs );
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
831 LeaveCriticalSection( &pdh_handle_cs );
832 return ERROR_SUCCESS;
833 }
834
835 /***********************************************************************
836 * PdhLookupPerfIndexByNameA (PDH.@)
837 */
838 PDH_STATUS WINAPI PdhLookupPerfIndexByNameA( LPCSTR machine, LPCSTR name, LPDWORD index )
839 {
840 PDH_STATUS ret;
841 WCHAR *machineW = NULL;
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
848 if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
849
850 if (!(nameW = pdh_strdup_aw( name )))
851 return PDH_MEMORY_ALLOCATION_FAILURE;
852
853 ret = PdhLookupPerfIndexByNameW( machineW, nameW, index );
854
855 heap_free( nameW );
856 heap_free( machineW );
857 return ret;
858 }
859
860 /***********************************************************************
861 * PdhLookupPerfIndexByNameW (PDH.@)
862 */
863 PDH_STATUS WINAPI PdhLookupPerfIndexByNameW( LPCWSTR machine, LPCWSTR name, LPDWORD index )
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");
874 return PDH_CSTATUS_NO_MACHINE;
875 }
876 for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
877 {
878 if (pdh_match_path( counter_sources[i].path, name ))
879 {
880 *index = counter_sources[i].index;
881 return ERROR_SUCCESS;
882 }
883 }
884 return PDH_STRING_NOT_FOUND;
885 }
886
887 /***********************************************************************
888 * PdhLookupPerfNameByIndexA (PDH.@)
889 */
890 PDH_STATUS WINAPI PdhLookupPerfNameByIndexA( LPCSTR machine, DWORD index, LPSTR buffer, LPDWORD size )
891 {
892 PDH_STATUS ret;
893 WCHAR *machineW = NULL;
894 WCHAR bufferW[PDH_MAX_COUNTER_NAME];
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
901 if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
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 }
911 heap_free( machineW );
912 return ret;
913 }
914
915 /***********************************************************************
916 * PdhLookupPerfNameByIndexW (PDH.@)
917 */
918 PDH_STATUS WINAPI PdhLookupPerfNameByIndexW( LPCWSTR machine, DWORD index, LPWSTR buffer, LPDWORD size )
919 {
920 PDH_STATUS ret;
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");
928 return PDH_CSTATUS_NO_MACHINE;
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 {
936 if (counter_sources[i].index == index)
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 );
945 ret = ERROR_SUCCESS;
946 }
947 *size = required;
948 return ret;
949 }
950 }
951 return PDH_INVALID_ARGUMENT;
952 }
953
954 /***********************************************************************
955 * PdhOpenQueryA (PDH.@)
956 */
957 PDH_STATUS WINAPI PdhOpenQueryA( LPCSTR source, DWORD_PTR userdata, PDH_HQUERY *query )
958 {
959 PDH_STATUS ret;
960 WCHAR *sourceW = NULL;
961
962 TRACE("%s %lx %p\n", debugstr_a(source), userdata, query);
963
964 if (source && !(sourceW = pdh_strdup_aw( source ))) return PDH_MEMORY_ALLOCATION_FAILURE;
965
966 ret = PdhOpenQueryW( sourceW, userdata, query );
967 heap_free( sourceW );
968
969 return ret;
970 }
971
972 /***********************************************************************
973 * PdhOpenQueryW (PDH.@)
974 */
975 PDH_STATUS WINAPI PdhOpenQueryW( LPCWSTR source, DWORD_PTR userdata, PDH_HQUERY *handle )
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");
986 return PDH_INVALID_ARGUMENT;
987 }
988 if ((query = create_query()))
989 {
990 query->user = userdata;
991 *handle = query;
992
993 return ERROR_SUCCESS;
994 }
995 return PDH_MEMORY_ALLOCATION_FAILURE;
996 }
997
998 /***********************************************************************
999 * PdhRemoveCounter (PDH.@)
1000 */
1001 PDH_STATUS WINAPI PdhRemoveCounter( PDH_HCOUNTER handle )
1002 {
1003 struct counter *counter = handle;
1004
1005 TRACE("%p\n", handle);
1006
1007 EnterCriticalSection( &pdh_handle_cs );
1008 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
1009 {
1010 LeaveCriticalSection( &pdh_handle_cs );
1011 return PDH_INVALID_HANDLE;
1012 }
1013
1014 list_remove( &counter->entry );
1015 destroy_counter( counter );
1016
1017 LeaveCriticalSection( &pdh_handle_cs );
1018 return ERROR_SUCCESS;
1019 }
1020
1021 /***********************************************************************
1022 * PdhSetCounterScaleFactor (PDH.@)
1023 */
1024 PDH_STATUS WINAPI PdhSetCounterScaleFactor( PDH_HCOUNTER handle, LONG factor )
1025 {
1026 struct counter *counter = handle;
1027
1028 TRACE("%p\n", handle);
1029
1030 EnterCriticalSection( &pdh_handle_cs );
1031 if (!counter || counter->magic != PDH_MAGIC_COUNTER)
1032 {
1033 LeaveCriticalSection( &pdh_handle_cs );
1034 return PDH_INVALID_HANDLE;
1035 }
1036 if (factor < PDH_MIN_SCALE || factor > PDH_MAX_SCALE)
1037 {
1038 LeaveCriticalSection( &pdh_handle_cs );
1039 return PDH_INVALID_ARGUMENT;
1040 }
1041
1042 counter->scale = factor;
1043
1044 LeaveCriticalSection( &pdh_handle_cs );
1045 return ERROR_SUCCESS;
1046 }
1047
1048 /***********************************************************************
1049 * PdhValidatePathA (PDH.@)
1050 */
1051 PDH_STATUS WINAPI PdhValidatePathA( LPCSTR path )
1052 {
1053 PDH_STATUS ret;
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 }
1066
1067 static PDH_STATUS validate_path( LPCWSTR path )
1068 {
1069 if (!path || !*path) return PDH_INVALID_ARGUMENT;
1070 if (*path++ != '\\' || !wcschr( path, '\\' )) return PDH_CSTATUS_BAD_COUNTERNAME;
1071 return ERROR_SUCCESS;
1072 }
1073
1074 /***********************************************************************
1075 * PdhValidatePathW (PDH.@)
1076 */
1077 PDH_STATUS WINAPI PdhValidatePathW( LPCWSTR path )
1078 {
1079 PDH_STATUS ret;
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++)
1087 if (pdh_match_path( counter_sources[i].path, path )) return ERROR_SUCCESS;
1088
1089 return PDH_CSTATUS_NO_COUNTER;
1090 }
1091
1092 /***********************************************************************
1093 * PdhVbAddCounter (PDH.@)
1094 */
1095 PDH_STATUS WINAPI PdhVbAddCounter( PDH_HQUERY query, LPCSTR path, PDH_HCOUNTER *counter )
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 }
1103
1104 /***********************************************************************
1105 * PdhValidatePathExA (PDH.@)
1106 */
1107 PDH_STATUS WINAPI PdhValidatePathExA( PDH_HLOG source, LPCSTR path )
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 }
1118
1119 /***********************************************************************
1120 * PdhValidatePathExW (PDH.@)
1121 */
1122 PDH_STATUS WINAPI PdhValidatePathExW( PDH_HLOG source, LPCWSTR path )
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 }
1133
1134 /***********************************************************************
1135 * PdhMakeCounterPathA (PDH.@)
1136 */
1137 PDH_STATUS WINAPI PdhMakeCounterPathA( PDH_COUNTER_PATH_ELEMENTS_A *e, LPSTR buffer,
1138 LPDWORD buflen, DWORD flags )
1139 {
1140 PDH_STATUS ret = PDH_MEMORY_ALLOCATION_FAILURE;
1141 PDH_COUNTER_PATH_ELEMENTS_W eW;
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
1173 ret = PDH_MEMORY_ALLOCATION_FAILURE;
1174 }
1175
1176 done:
1177 heap_free( eW.szMachineName );
1178 heap_free( eW.szObjectName );
1179 heap_free( eW.szInstanceName );
1180 heap_free( eW.szParentInstance );
1181 heap_free( eW.szCounterName );
1182 return ret;
1183 }
1184
1185 /***********************************************************************
1186 * PdhMakeCounterPathW (PDH.@)
1187 */
1188 PDH_STATUS WINAPI PdhMakeCounterPathW( PDH_COUNTER_PATH_ELEMENTS_W *e, LPWSTR buffer,
1189 LPDWORD buflen, DWORD flags )
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
1197 WCHAR path[PDH_MAX_COUNTER_NAME], instance[12];
1198 PDH_STATUS ret = ERROR_SUCCESS;
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);
1227 lstrcatW(path, instance);
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 }
1239
1240 /***********************************************************************
1241 * PdhEnumObjectItemsA (PDH.@)
1242 */
1243 PDH_STATUS WINAPI PdhEnumObjectItemsA(LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName,
1244 LPSTR mszCounterList, LPDWORD pcchCounterListLength, LPSTR mszInstanceList,
1245 LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
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 }
1253
1254 /***********************************************************************
1255 * PdhEnumObjectItemsW (PDH.@)
1256 */
1257 PDH_STATUS WINAPI PdhEnumObjectItemsW(LPCWSTR szDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName,
1258 LPWSTR mszCounterList, LPDWORD pcchCounterListLength, LPWSTR mszInstanceList,
1259 LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
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 }
1267
1268 /***********************************************************************
1269 * PdhSetDefaultRealTimeDataSource (PDH.@)
1270 */
1271 PDH_STATUS WINAPI PdhSetDefaultRealTimeDataSource( DWORD source )
1272 {
1273 FIXME("%u\n", source);
1274 return ERROR_SUCCESS;
1275 }
1276
1277 /***********************************************************************
1278 * PdhGetLogFileTypeA (PDH.@)
1279 */
1280 PDH_STATUS WINAPI PdhGetLogFileTypeA(const char *log, DWORD *type)
1281 {
1282 FIXME("%s, %p: stub\n", debugstr_a(log), type);
1283 return PDH_NOT_IMPLEMENTED;
1284 }
1285
1286 /***********************************************************************
1287 * PdhGetLogFileTypeW (PDH.@)
1288 */
1289 PDH_STATUS WINAPI PdhGetLogFileTypeW(const WCHAR *log, DWORD *type)
1290 {
1291 FIXME("%s, %p: stub\n", debugstr_w(log), type);
1292 return PDH_NOT_IMPLEMENTED;
1293 }
1294
1295 /***********************************************************************
1296 * PdhBindInputDataSourceA (PDH.@)
1297 */
1298 PDH_STATUS WINAPI PdhBindInputDataSourceA(PDH_HLOG *source, const char *filenamelist)
1299 {
1300 FIXME("%p %s: stub\n", source, debugstr_a(filenamelist));
1301 return PDH_NOT_IMPLEMENTED;
1302 }
1303
1304 /***********************************************************************
1305 * PdhBindInputDataSourceW (PDH.@)
1306 */
1307 PDH_STATUS WINAPI PdhBindInputDataSourceW(PDH_HLOG *source, const WCHAR *filenamelist)
1308 {
1309 FIXME("%p %s: stub\n", source, debugstr_w(filenamelist));
1310 return PDH_NOT_IMPLEMENTED;
1311 }
A free Windows-compatible Operating System