git.oblomov.eu Git - wine/blob - 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 #define NONAMELESSSTRUCT
  27 #include "windef.h"
  28 #include "winbase.h"
  29
  30 #include "pdh.h"
  31 #include "pdhmsg.h"
  32 #include "winperf.h"
  33
  34 #include "wine/debug.h"
  35 #include "wine/list.h"
  36 #include "wine/unicode.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(pdh);
  39
  40 static inline void *pdh_alloc( SIZE_T size )
  41 {
  42     return HeapAlloc( GetProcessHeap(), 0, size );
  43 }
  44
  45 static inline void *pdh_alloc_zero( SIZE_T size )
  46 {
  47     return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
  48 }
  49
  50 static inline void pdh_free( LPVOID mem )
  51 {
  52     HeapFree( GetProcessHeap(), 0, mem );
  53 }
  54
  55 static inline WCHAR *pdh_strdup( const WCHAR *src )
  56 {
  57     WCHAR *dst;
  58
  59     if (!src) return NULL;
  60     if ((dst = pdh_alloc( (strlenW( src ) + 1) * sizeof(WCHAR) ))) strcpyW( dst, src );
  61     return dst;
  62 }
  63
  64 static inline WCHAR *pdh_strdup_aw( const char *src )
  65 {
  66     int len;
  67     WCHAR *dst;
  68
  69     if (!src) return NULL;
  70     len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
  71     if ((dst = pdh_alloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
  72     return dst;
  73 }
  74
  75 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  76 {
  77     TRACE("(0x%p, %d, %p)\n",hinstDLL,fdwReason,lpvReserved);
  78
  79     if (fdwReason == DLL_WINE_PREATTACH) return FALSE;    /* prefer native version */
  80
  81     if (fdwReason == DLL_PROCESS_ATTACH)
  82     {
  83         DisableThreadLibraryCalls( hinstDLL );
  84     }
  85
  86     return TRUE;
  87 }
  88
  89 struct counter
  90 {
  91     struct list     entry;
  92     WCHAR          *path;                           /* identifier */
  93     DWORD           type;                           /* counter type */
  94     DWORD           status;                         /* update status */
  95     LONG            scale;                          /* scale factor */
  96     LONG            defaultscale;                   /* default scale factor */
  97     DWORD_PTR       user;                           /* user data */
  98     DWORD_PTR       queryuser;                      /* query user data */
  99     LONGLONG        base;                           /* samples per second */
 100     FILETIME        stamp;                          /* time stamp */
 101     void (CALLBACK *collect)( struct counter * );   /* collect callback */
 102     union
 103     {
 104         LONG     longvalue;
 105         double   doublevalue;
 106         LONGLONG largevalue;
 107     } one;                                          /* first value */
 108     union
 109     {
 110         LONG     longvalue;
 111         double   doublevalue;
 112         LONGLONG largevalue;
 113     } two;                                          /* second value */
 114 };
 115
 116 static struct counter *create_counter( void )
 117 {
 118     struct counter *counter;
 119
 120     if ((counter = pdh_alloc_zero( sizeof(struct counter) ))) return counter;
 121     return NULL;
 122 }
 123
 124 #define PDH_MAGIC_QUERY     0x50444830 /* 'PDH0' */
 125
 126 struct query
 127 {
 128     DWORD       magic;      /* signature */
 129     DWORD_PTR   user;       /* user data */
 130     struct list counters;   /* counter list */
 131 };
 132
 133 static struct query *create_query( void )
 134 {
 135     struct query *query;
 136
 137     if ((query = pdh_alloc_zero( sizeof(struct query) )))
 138     {
 139         query->magic = PDH_MAGIC_QUERY;
 140         list_init( &query->counters );
 141         return query;
 142     }
 143     return NULL;
 144 }
 145
 146 struct source
 147 {
 148     const WCHAR    *path;                           /* identifier */
 149     void (CALLBACK *collect)( struct counter * );   /* collect callback */
 150     DWORD           type;                           /* counter type */
 151     LONG            scale;                          /* default scale factor */
 152     LONGLONG        base;                           /* samples per second */
 153 };
 154
 155 static const WCHAR path_uptime[] =
 156     {'\\','S','y','s','t','e','m', '\\', 'S','y','s','t','e','m',' ','U','p',' ','T','i','m','e',0};
 157
 158 static void CALLBACK collect_uptime( struct counter *counter )
 159 {
 160     counter->two.largevalue = GetTickCount(); /* FIXME */
 161     counter->status = PDH_CSTATUS_VALID_DATA;
 162 }
 163
 164 #define TYPE_UPTIME \
 165     (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)
 166
 167 /* counter source registry */
 168 static const struct source counter_sources[] =
 169 {
 170     { path_uptime, collect_uptime, TYPE_UPTIME, -3, 1000 }
 171 };
 172
 173 /***********************************************************************
 174  *              PdhAddCounterA   (PDH.@)
 175  */
 176 PDH_STATUS WINAPI PdhAddCounterA( PDH_HQUERY query, LPCSTR path,
 177                                   DWORD_PTR userdata, PDH_HCOUNTER *counter )
 178 {
 179     PDH_STATUS ret;
 180     WCHAR *pathW;
 181
 182     TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
 183
 184     if (!path) return PDH_INVALID_ARGUMENT;
 185
 186     if (!(pathW = pdh_strdup_aw( path )))
 187         return PDH_MEMORY_ALLOCATION_FAILURE;
 188
 189     ret = PdhAddCounterW( query, pathW, userdata, counter );
 190
 191     pdh_free( pathW );
 192     return ret;
 193 }
 194
 195 /***********************************************************************
 196  *              PdhAddCounterW   (PDH.@)
 197  */
 198 PDH_STATUS WINAPI PdhAddCounterW( PDH_HQUERY hquery, LPCWSTR path,
 199                                   DWORD_PTR userdata, PDH_HCOUNTER *hcounter )
 200 {
 201     struct query *query = hquery;
 202     struct counter *counter;
 203     unsigned int i;
 204
 205     TRACE("%p %s %lx %p\n", hquery, debugstr_w(path), userdata, hcounter);
 206
 207     if (!path  || !hcounter) return PDH_INVALID_ARGUMENT;
 208     if (!query || (query->magic != PDH_MAGIC_QUERY)) return PDH_INVALID_HANDLE;
 209
 210     *hcounter = NULL;
 211     for (i = 0; i < sizeof(counter_sources) / sizeof(counter_sources[0]); i++)
 212     {
 213         if (strstrW( path, counter_sources[i].path ))
 214         {
 215             if ((counter = create_counter()))
 216             {
 217                 counter->path         = pdh_strdup( counter_sources[i].path );
 218                 counter->collect      = counter_sources[i].collect;
 219                 counter->type         = counter_sources[i].type;
 220                 counter->defaultscale = counter_sources[i].scale;
 221                 counter->base         = counter_sources[i].base;
 222                 counter->queryuser    = query->user;
 223                 counter->user         = userdata;
 224
 225                 list_add_tail( &query->counters, &counter->entry );
 226
 227                 *hcounter = counter;
 228                 return ERROR_SUCCESS;
 229             }
 230             return PDH_MEMORY_ALLOCATION_FAILURE;
 231         }
 232     }
 233     return PDH_CSTATUS_NO_COUNTER;
 234 }
 235
 236 /***********************************************************************
 237  *              PdhCloseQuery   (PDH.@)
 238  */
 239 PDH_STATUS WINAPI PdhCloseQuery( PDH_HQUERY handle )
 240 {
 241     struct query *query = handle;
 242     struct list *item;
 243
 244     TRACE("%p\n", handle);
 245
 246     if (!query || (query->magic != PDH_MAGIC_QUERY)) return PDH_INVALID_HANDLE;
 247
 248     LIST_FOR_EACH( item, &query->counters )
 249     {
 250         struct counter *counter = LIST_ENTRY( item, struct counter, entry );
 251
 252         list_remove( &counter->entry );
 253
 254         pdh_free( counter->path );
 255         pdh_free( counter );
 256     }
 257
 258     pdh_free( query );
 259     return ERROR_SUCCESS;
 260 }
 261
 262 /***********************************************************************
 263  *              PdhCollectQueryData   (PDH.@)
 264  */
 265 PDH_STATUS WINAPI PdhCollectQueryData( PDH_HQUERY handle )
 266 {
 267     struct query *query = handle;
 268     struct list *item;
 269
 270     TRACE("%p\n", handle);
 271
 272     if (!query || (query->magic != PDH_MAGIC_QUERY)) return PDH_INVALID_HANDLE;
 273
 274     LIST_FOR_EACH( item, &query->counters )
 275     {
 276         SYSTEMTIME time;
 277         struct counter *counter = LIST_ENTRY( item, struct counter, entry );
 278
 279         counter->collect( counter );
 280
 281         GetLocalTime( &time );
 282         SystemTimeToFileTime( &time, &counter->stamp );
 283     }
 284     return ERROR_SUCCESS;
 285 }
 286
 287 /***********************************************************************
 288  *              PdhGetCounterInfoA   (PDH.@)
 289  */
 290 PDH_STATUS WINAPI PdhGetCounterInfoA( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_A info )
 291 {
 292     struct counter *counter = handle;
 293
 294     TRACE("%p %d %p %p\n", handle, text, size, info);
 295
 296     if (!counter) return PDH_INVALID_HANDLE;
 297     if (!size)    return PDH_INVALID_ARGUMENT;
 298
 299     if (*size < sizeof(PDH_COUNTER_INFO_A))
 300     {
 301         *size = sizeof(PDH_COUNTER_INFO_A);
 302         return PDH_MORE_DATA;
 303     }
 304
 305     memset( info, 0, sizeof(PDH_COUNTER_INFO_A) );
 306
 307     info->dwType          = counter->type;
 308     info->CStatus         = counter->status;
 309     info->lScale          = counter->scale;
 310     info->lDefaultScale   = counter->defaultscale;
 311     info->dwUserData      = counter->user;
 312     info->dwQueryUserData = counter->queryuser;
 313
 314     *size = sizeof(PDH_COUNTER_INFO_A);
 315     return ERROR_SUCCESS;
 316 }
 317
 318 /***********************************************************************
 319  *              PdhGetCounterInfoW   (PDH.@)
 320  */
 321 PDH_STATUS WINAPI PdhGetCounterInfoW( PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_W info )
 322 {
 323     struct counter *counter = handle;
 324
 325     TRACE("%p %d %p %p\n", handle, text, size, info);
 326
 327     if (!size)    return PDH_INVALID_ARGUMENT;
 328     if (!counter) return PDH_INVALID_HANDLE;
 329
 330     if (*size < sizeof(PDH_COUNTER_INFO_W))
 331     {
 332         *size = sizeof(PDH_COUNTER_INFO_W);
 333         return PDH_MORE_DATA;
 334     }
 335
 336     memset( info, 0, sizeof(PDH_COUNTER_INFO_W) );
 337
 338     info->dwType          = counter->type;
 339     info->CStatus         = counter->status;
 340     info->lScale          = counter->scale;
 341     info->lDefaultScale   = counter->defaultscale;
 342     info->dwUserData      = counter->user;
 343     info->dwQueryUserData = counter->queryuser;
 344
 345     *size = sizeof(PDH_COUNTER_INFO_A);
 346     return ERROR_SUCCESS;
 347 }
 348
 349 /***********************************************************************
 350  *              PdhGetCounterTimeBase   (PDH.@)
 351  */
 352 PDH_STATUS WINAPI PdhGetCounterTimeBase( PDH_HCOUNTER handle, LONGLONG *base )
 353 {
 354     struct counter *counter = handle;
 355
 356     TRACE("%p %p\n", handle, base);
 357
 358     if (!base)    return PDH_INVALID_ARGUMENT;
 359     if (!counter) return PDH_INVALID_HANDLE;
 360
 361     *base = counter->base;
 362     return ERROR_SUCCESS;
 363 }
 364
 365 /***********************************************************************
 366  *              PdhGetFormattedCounterValue   (PDH.@)
 367  */
 368 PDH_STATUS WINAPI PdhGetFormattedCounterValue( PDH_HCOUNTER handle, DWORD format,
 369                                                LPDWORD type, PPDH_FMT_COUNTERVALUE value )
 370 {
 371     LONG factor;
 372     struct counter *counter = handle;
 373
 374     TRACE("%p %x %p %p\n", handle, format, type, value);
 375
 376     if (!value)   return PDH_INVALID_ARGUMENT;
 377     if (!counter) return PDH_INVALID_HANDLE;
 378
 379     if (counter->status) return PDH_INVALID_DATA;
 380
 381     factor = counter->scale ? counter->scale : counter->defaultscale;
 382     if (format & PDH_FMT_LONG)
 383     {
 384         if (format & PDH_FMT_1000) value->u.longValue = counter->two.longvalue * 1000;
 385         else value->u.longValue = counter->two.longvalue * pow( 10, factor );
 386     }
 387     else if (format & PDH_FMT_LARGE)
 388     {
 389         if (format & PDH_FMT_1000) value->u.longValue = counter->two.largevalue * 1000;
 390         else value->u.largeValue = counter->two.largevalue * pow( 10, factor );
 391     }
 392     else if (format & PDH_FMT_DOUBLE)
 393     {
 394         if (format & PDH_FMT_1000) value->u.longValue = counter->two.doublevalue * 1000;
 395         else value->u.doubleValue = counter->two.doublevalue * pow( 10, factor );
 396     }
 397     else
 398     {
 399         WARN("unknown format %x\n", format);
 400         return PDH_INVALID_ARGUMENT;
 401     }
 402     value->CStatus = ERROR_SUCCESS;
 403
 404     if (type) *type = counter->type;
 405     return ERROR_SUCCESS;
 406 }
 407
 408 /***********************************************************************
 409  *              PdhGetRawCounterValue   (PDH.@)
 410  */
 411 PDH_STATUS WINAPI PdhGetRawCounterValue( PDH_HCOUNTER handle, LPDWORD type,
 412                                          PPDH_RAW_COUNTER value )
 413 {
 414     struct counter *counter = handle;
 415
 416     TRACE("%p %p %p\n", handle, type, value);
 417
 418     if (!value)   return PDH_INVALID_ARGUMENT;
 419     if (!counter) return PDH_INVALID_HANDLE;
 420
 421     value->CStatus                  = counter->status;
 422     value->TimeStamp.dwLowDateTime  = counter->stamp.dwLowDateTime;
 423     value->TimeStamp.dwHighDateTime = counter->stamp.dwHighDateTime;
 424     value->FirstValue               = counter->one.largevalue;;
 425     value->SecondValue              = counter->two.largevalue;
 426     value->MultiCount               = 1; /* FIXME */
 427
 428     if (type) *type = counter->type;
 429     return ERROR_SUCCESS;
 430 }
 431
 432 /***********************************************************************
 433  *              PdhOpenQueryA   (PDH.@)
 434  */
 435 PDH_STATUS WINAPI PdhOpenQueryA( LPCSTR source, DWORD_PTR userdata, PDH_HQUERY *query )
 436 {
 437     PDH_STATUS ret;
 438     WCHAR *sourceW = NULL;
 439
 440     TRACE("%s %lx %p\n", debugstr_a(source), userdata, query);
 441
 442     if (source && !(sourceW = pdh_strdup_aw( source ))) return PDH_MEMORY_ALLOCATION_FAILURE;
 443
 444     ret = PdhOpenQueryW( sourceW, userdata, query );
 445     pdh_free( sourceW );
 446
 447     return ret;
 448 }
 449
 450 /***********************************************************************
 451  *              PdhOpenQueryW   (PDH.@)
 452  */
 453 PDH_STATUS WINAPI PdhOpenQueryW( LPCWSTR source, DWORD_PTR userdata, PDH_HQUERY *handle )
 454 {
 455     struct query *query;
 456
 457     TRACE("%s %lx %p\n", debugstr_w(source), userdata, handle);
 458
 459     if (!handle) return PDH_INVALID_ARGUMENT;
 460
 461     if (source)
 462     {
 463         FIXME("log file data source not supported\n");
 464         return PDH_INVALID_ARGUMENT;
 465     }
 466     if ((query = create_query()))
 467     {
 468         query->user = userdata;
 469         *handle = query;
 470
 471         return ERROR_SUCCESS;
 472     }
 473     return PDH_MEMORY_ALLOCATION_FAILURE;
 474 }
 475
 476 /***********************************************************************
 477  *              PdhRemoveCounter   (PDH.@)
 478  */
 479 PDH_STATUS WINAPI PdhRemoveCounter( PDH_HCOUNTER handle )
 480 {
 481     struct counter *counter = handle;
 482
 483     TRACE("%p\n", handle);
 484
 485     if (!counter) return PDH_INVALID_HANDLE;
 486
 487     list_remove( &counter->entry );
 488
 489     pdh_free( counter->path );
 490     pdh_free( counter );
 491
 492     return ERROR_SUCCESS;
 493 }
 494
 495 /***********************************************************************
 496  *              PdhSetCounterScaleFactor   (PDH.@)
 497  */
 498 PDH_STATUS WINAPI PdhSetCounterScaleFactor( PDH_HCOUNTER handle, LONG factor )
 499 {
 500     struct counter *counter = handle;
 501
 502     TRACE("%p\n", handle);
 503
 504     if (!counter) return PDH_INVALID_HANDLE;
 505     if (factor < PDH_MIN_SCALE || factor > PDH_MAX_SCALE) return PDH_INVALID_ARGUMENT;
 506
 507     counter->scale = factor;
 508     return ERROR_SUCCESS;
 509 }