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