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