pdh_main.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "pdh.h"
#include "pdhmsg.h"
#include "winperf.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for pdh_main.c:

Go to the source code of this file.

Classes
union	value
struct	counter
struct	query
struct	source

Macros
#define	PDH_MAGIC_COUNTER   0x50444831 /* 'PDH1' */
#define	PDH_MAGIC_QUERY   0x50444830 /* 'PDH0' */
#define	TYPE_PROCESSOR_TIME
#define	TYPE_UPTIME    (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (pdh)
static WCHAR *	pdh_strdup_aw (const char *src)
static struct counter *	create_counter (void)
static void	destroy_counter (struct counter *counter)
static struct query *	create_query (void)
static void	destroy_query (struct query *query)
static void CALLBACK	collect_processor_time (struct counter *counter)
static void CALLBACK	collect_uptime (struct counter *counter)
static BOOL	is_local_machine (const WCHAR *name, DWORD len)
static BOOL	pdh_match_path (LPCWSTR fullpath, LPCWSTR path)
PDH_STATUS WINAPI	PdhAddCounterA (PDH_HQUERY query, LPCSTR path, DWORD_PTR userdata, PDH_HCOUNTER *counter)
PDH_STATUS WINAPI	PdhAddCounterW (PDH_HQUERY hquery, LPCWSTR path, DWORD_PTR userdata, PDH_HCOUNTER *hcounter)
PDH_STATUS WINAPI	PdhAddEnglishCounterA (PDH_HQUERY query, LPCSTR path, DWORD_PTR userdata, PDH_HCOUNTER *counter)
PDH_STATUS WINAPI	PdhAddEnglishCounterW (PDH_HQUERY query, LPCWSTR path, DWORD_PTR userdata, PDH_HCOUNTER *counter)
static PDH_STATUS	format_value (struct counter *counter, DWORD format, union value *raw1, union value *raw2, PDH_FMT_COUNTERVALUE *value)
PDH_STATUS WINAPI	PdhCalculateCounterFromRawValue (PDH_HCOUNTER handle, DWORD format, PPDH_RAW_COUNTER raw1, PPDH_RAW_COUNTER raw2, PPDH_FMT_COUNTERVALUE value)
PDH_STATUS WINAPI	PdhCloseQuery (PDH_HQUERY handle)
static void	collect_query_data (struct query *query)
PDH_STATUS WINAPI	PdhCollectQueryData (PDH_HQUERY handle)
static DWORD CALLBACK	collect_query_thread (void *arg)
PDH_STATUS WINAPI	PdhCollectQueryDataEx (PDH_HQUERY handle, DWORD interval, HANDLE event)
PDH_STATUS WINAPI	PdhCollectQueryDataWithTime (PDH_HQUERY handle, LONGLONG *timestamp)
PDH_STATUS WINAPI	PdhExpandWildCardPathA (LPCSTR szDataSource, LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags)
PDH_STATUS WINAPI	PdhExpandWildCardPathW (LPCWSTR szDataSource, LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags)
PDH_STATUS WINAPI	PdhExpandCounterPathA (LPCSTR szWildCardPath, LPSTR mszExpandedPathList, LPDWORD pcchPathListLength)
PDH_STATUS WINAPI	PdhExpandCounterPathW (LPCWSTR szWildCardPath, LPWSTR mszExpandedPathList, LPDWORD pcchPathListLength)
PDH_STATUS WINAPI	PdhGetCounterInfoA (PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_A info)
PDH_STATUS WINAPI	PdhGetCounterInfoW (PDH_HCOUNTER handle, BOOLEAN text, LPDWORD size, PPDH_COUNTER_INFO_W info)
PDH_STATUS WINAPI	PdhGetCounterTimeBase (PDH_HCOUNTER handle, LONGLONG *base)
PDH_STATUS WINAPI	PdhGetDllVersion (LPDWORD version)
PDH_STATUS WINAPI	PdhGetFormattedCounterValue (PDH_HCOUNTER handle, DWORD format, LPDWORD type, PPDH_FMT_COUNTERVALUE value)
PDH_STATUS WINAPI	PdhGetRawCounterValue (PDH_HCOUNTER handle, LPDWORD type, PPDH_RAW_COUNTER value)
PDH_STATUS WINAPI	PdhLookupPerfIndexByNameA (LPCSTR machine, LPCSTR name, LPDWORD index)
PDH_STATUS WINAPI	PdhLookupPerfIndexByNameW (LPCWSTR machine, LPCWSTR name, LPDWORD index)
PDH_STATUS WINAPI	PdhLookupPerfNameByIndexA (LPCSTR machine, DWORD index, LPSTR buffer, LPDWORD size)
PDH_STATUS WINAPI	PdhLookupPerfNameByIndexW (LPCWSTR machine, DWORD index, LPWSTR buffer, LPDWORD size)
PDH_STATUS WINAPI	PdhOpenQueryA (LPCSTR source, DWORD_PTR userdata, PDH_HQUERY *query)
PDH_STATUS WINAPI	PdhOpenQueryW (LPCWSTR source, DWORD_PTR userdata, PDH_HQUERY *handle)
PDH_STATUS WINAPI	PdhRemoveCounter (PDH_HCOUNTER handle)
PDH_STATUS WINAPI	PdhSetCounterScaleFactor (PDH_HCOUNTER handle, LONG factor)
PDH_STATUS WINAPI	PdhValidatePathA (LPCSTR path)
static PDH_STATUS	validate_path (LPCWSTR path)
PDH_STATUS WINAPI	PdhValidatePathW (LPCWSTR path)
PDH_STATUS WINAPI	PdhVbAddCounter (PDH_HQUERY query, LPCSTR path, PDH_HCOUNTER *counter)
double WINAPI	PdhVbGetDoubleCounterValue (PDH_HCOUNTER handle, PDH_STATUS *counter_status)
PDH_STATUS WINAPI	PdhValidatePathExA (PDH_HLOG source, LPCSTR path)
PDH_STATUS WINAPI	PdhValidatePathExW (PDH_HLOG source, LPCWSTR path)
PDH_STATUS WINAPI	PdhMakeCounterPathA (PDH_COUNTER_PATH_ELEMENTS_A *e, LPSTR buffer, LPDWORD buflen, DWORD flags)
PDH_STATUS WINAPI	PdhMakeCounterPathW (PDH_COUNTER_PATH_ELEMENTS_W *e, LPWSTR buffer, LPDWORD buflen, DWORD flags)
PDH_STATUS WINAPI	PdhEnumObjectItemsA (LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName, LPSTR mszCounterList, LPDWORD pcchCounterListLength, LPSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
PDH_STATUS WINAPI	PdhEnumObjectItemsW (LPCWSTR szDataSource, LPCWSTR szMachineName, LPCWSTR szObjectName, LPWSTR mszCounterList, LPDWORD pcchCounterListLength, LPWSTR mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags)
PDH_STATUS WINAPI	PdhSetDefaultRealTimeDataSource (DWORD source)
PDH_STATUS WINAPI	PdhGetLogFileTypeA (const char *log, DWORD *type)
PDH_STATUS WINAPI	PdhGetLogFileTypeW (const WCHAR *log, DWORD *type)
PDH_STATUS WINAPI	PdhBindInputDataSourceA (PDH_HLOG *source, const char *filenamelist)
PDH_STATUS WINAPI	PdhBindInputDataSourceW (PDH_HLOG *source, const WCHAR *filenamelist)
PDH_STATUS WINAPI	PdhConnectMachineA (const char *name)

Variables
static CRITICAL_SECTION	pdh_handle_cs = { &pdh_handle_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	pdh_handle_cs_debug
static const struct source	counter_sources []

Macro Definition Documentation

PDH_MAGIC_COUNTER

#define PDH_MAGIC_COUNTER   0x50444831 /* 'PDH1' */

Definition at line 88 of file pdh_main.c.

PDH_MAGIC_QUERY

#define PDH_MAGIC_QUERY   0x50444830 /* 'PDH0' */

Definition at line 110 of file pdh_main.c.

TYPE_PROCESSOR_TIME

#define TYPE_PROCESSOR_TIME

Value:

    (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | \
     PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)

Definition at line 165 of file pdh_main.c.

TYPE_UPTIME

#define TYPE_UPTIME    (PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)

Definition at line 169 of file pdh_main.c.

Function Documentation

collect_processor_time()

static void CALLBACK collect_processor_time ( struct counter *  counter )

static

Definition at line 153 of file pdh_main.c.

{
    counter->two.largevalue = 500000; /* FIXME */
    counter->status = PDH_CSTATUS_VALID_DATA;
}

collect_query_data()

static void collect_query_data ( struct query *  query )

static

Definition at line 410 of file pdh_main.c.

{
    struct list *item;
 
    LIST_FOR_EACH( item, &query->counters )
    {
        SYSTEMTIME time;
        struct counter *counter = LIST_ENTRY( item, struct counter, entry );
 
        counter->collect( counter );
 
        GetLocalTime( &time );
        SystemTimeToFileTime( &time, &counter->stamp );
    }
}

Referenced by collect_query_thread(), PdhCollectQueryData(), and PdhCollectQueryDataWithTime().

collect_query_thread()

static DWORD CALLBACK collect_query_thread ( void *  arg )

static

Definition at line 454 of file pdh_main.c.

{
    struct query *query = arg;
    DWORD interval = query->interval;
    HANDLE stop = query->stop;
 
    for (;;)
    {
        if (WaitForSingleObject( stop, interval ) != WAIT_TIMEOUT) ExitThread( 0 );
 
        EnterCriticalSection( &pdh_handle_cs );
        if (query->magic != PDH_MAGIC_QUERY)
        {
            LeaveCriticalSection( &pdh_handle_cs );
            ExitThread( PDH_INVALID_HANDLE );
        }
 
        collect_query_data( query );
 
        if (!SetEvent( query->wait ))
        {
            LeaveCriticalSection( &pdh_handle_cs );
            ExitThread( 0 );
        }
        LeaveCriticalSection( &pdh_handle_cs );
    }
}

Referenced by PdhCollectQueryDataEx().

collect_uptime()

static void CALLBACK collect_uptime ( struct counter *  counter )

static

Definition at line 159 of file pdh_main.c.

{
    counter->two.largevalue = GetTickCount64();
    counter->status = PDH_CSTATUS_VALID_DATA;
}

create_counter()

static struct counter * create_counter ( void  )

static

Definition at line 90 of file pdh_main.c.

{
    struct counter *counter;
 
    if ((counter = calloc( 1, sizeof(struct counter) )))
    {
        counter->magic = PDH_MAGIC_COUNTER;
        return counter;
    }
    return NULL;
}

Referenced by PdhAddCounterW().

create_query()

static struct query * create_query ( void  )

static

Definition at line 123 of file pdh_main.c.

{
    struct query *query;
 
    if ((query = calloc( 1, sizeof(struct query) )))
    {
        query->magic = PDH_MAGIC_QUERY;
        list_init( &query->counters );
        return query;
    }
    return NULL;
}

Referenced by get_diskdrivetodiskpartition_pairs(), get_logicaldisktopartition_pairs(), msi_table_apply_transform(), PdhOpenQueryW(), and wbem_services_ExecMethod().

destroy_counter()

static void destroy_counter ( struct counter *  counter )

static

Definition at line 102 of file pdh_main.c.

{
    /* Ensure compiler doesn't optimize out the assignment with 0. */
    SecureZeroMemory( &counter->magic, sizeof( counter->magic ) );
    free( counter->path );
    free( counter );
}

Referenced by PdhCloseQuery(), and PdhRemoveCounter().

destroy_query()

static void destroy_query ( struct query *  query )

static

Definition at line 136 of file pdh_main.c.

{
    /* Ensure compiler doesn't optimize out the assignment with 0. */
    SecureZeroMemory( &query->magic, sizeof( query->magic ) );
    free( query );
}

Referenced by PdhCloseQuery().

format_value()

static PDH_STATUS format_value ( struct counter *  counter, DWORD  format, union value *  raw1, union value *  raw2, PDH_FMT_COUNTERVALUE *  value  )

static

Definition at line 301 of file pdh_main.c.

{
    LONG factor;
 
    factor = counter->scale ? counter->scale : counter->defaultscale;
    if (format & PDH_FMT_LONG)
    {
        if (format & PDH_FMT_1000) value->longValue = raw2->longvalue * 1000;
        else value->longValue = raw2->longvalue * pow( 10, factor );
    }
    else if (format & PDH_FMT_LARGE)
    {
        if (format & PDH_FMT_1000) value->largeValue = raw2->largevalue * 1000;
        else value->largeValue = raw2->largevalue * pow( 10, factor );
    }
    else if (format & PDH_FMT_DOUBLE)
    {
        if (format & PDH_FMT_1000) value->doubleValue = raw2->doublevalue * 1000;
        else value->doubleValue = raw2->doublevalue * pow( 10, factor );
    }
    else
    {
        WARN("unknown format %lx\n", format);
        return PDH_INVALID_ARGUMENT;
    }
    return ERROR_SUCCESS;
}

Referenced by PdhCalculateCounterFromRawValue(), and PdhGetFormattedCounterValue().

is_local_machine()

static BOOL is_local_machine ( const WCHAR *  name, DWORD  len  )

static

Definition at line 179 of file pdh_main.c.

{
    WCHAR buf[MAX_COMPUTERNAME_LENGTH + 1];
    DWORD buflen = ARRAY_SIZE(buf);
 
    if (!GetComputerNameW( buf, &buflen )) return FALSE;
    return len == buflen && !wcsnicmp( name, buf, buflen );
}

Referenced by pdh_match_path().

pdh_match_path()

static BOOL pdh_match_path ( LPCWSTR  fullpath, LPCWSTR  path  )

static

Definition at line 188 of file pdh_main.c.

{
    const WCHAR *p;
 
    if (path[0] == '\\' && path[1] == '\\' && (p = wcschr( path + 2, '\\' )) &&
        is_local_machine( path + 2, p - path - 2 ))
    {
        path += p - path;
    }
    if (wcschr( path, '\\' )) p = fullpath;
    else p = wcsrchr( fullpath, '\\' ) + 1;
    return !wcscmp( p, path );
}

Referenced by PdhAddCounterW(), PdhLookupPerfIndexByNameW(), and PdhValidatePathW().

pdh_strdup_aw()

static WCHAR * pdh_strdup_aw ( const char *  src )

inlinestatic

Definition at line 52 of file pdh_main.c.

{
    int len;
    WCHAR *dst;
 
    if (!src) return NULL;
    len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
    if ((dst = malloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
    return dst;
}

Referenced by PdhAddCounterA(), PdhLookupPerfIndexByNameA(), PdhLookupPerfNameByIndexA(), PdhMakeCounterPathA(), PdhOpenQueryA(), and PdhValidatePathA().

PdhAddCounterA()

PDH_STATUS WINAPI PdhAddCounterA	(	PDH_HQUERY	query,
		LPCSTR	path,
		DWORD_PTR	userdata,
		PDH_HCOUNTER *	counter
	)

Definition at line 205 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *pathW;
 
    TRACE("%p %s %Ix %p\n", query, debugstr_a(path), userdata, counter);
 
    if (!path) return PDH_INVALID_ARGUMENT;
 
    if (!(pathW = pdh_strdup_aw( path )))
        return PDH_MEMORY_ALLOCATION_FAILURE;
 
    ret = PdhAddCounterW( query, pathW, userdata, counter );
 
    free( pathW );
    return ret;
}

Referenced by PdhAddEnglishCounterA(), test_PdhAddCounterA(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), test_PdhSetCounterScaleFactor(), and test_PdhVbGetDoubleCounterValue().

PdhAddCounterW()

PDH_STATUS WINAPI PdhAddCounterW	(	PDH_HQUERY	hquery,
		LPCWSTR	path,
		DWORD_PTR	userdata,
		PDH_HCOUNTER *	hcounter
	)

Definition at line 227 of file pdh_main.c.

{
    struct query *query = hquery;
    struct counter *counter;
    unsigned int i;
 
    TRACE("%p %s %Ix %p\n", hquery, debugstr_w(path), userdata, hcounter);
 
    if (!path  || !hcounter) return PDH_INVALID_ARGUMENT;
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
 
    *hcounter = NULL;
    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
    {
        if (pdh_match_path( counter_sources[i].path, path ))
        {
            if ((counter = create_counter()))
            {
                counter->path         = wcsdup( counter_sources[i].path );
                counter->collect      = counter_sources[i].collect;
                counter->type         = counter_sources[i].type;
                counter->defaultscale = counter_sources[i].scale;
                counter->base         = counter_sources[i].base;
                counter->queryuser    = query->user;
                counter->user         = userdata;
 
                list_add_tail( &query->counters, &counter->entry );
                *hcounter = counter;
 
                LeaveCriticalSection( &pdh_handle_cs );
                return ERROR_SUCCESS;
            }
            LeaveCriticalSection( &pdh_handle_cs );
            return PDH_MEMORY_ALLOCATION_FAILURE;
        }
    }
    LeaveCriticalSection( &pdh_handle_cs );
    return PDH_CSTATUS_NO_COUNTER;
}

Referenced by PdhAddCounterA(), PdhAddEnglishCounterW(), test_PdhAddCounterW(), and test_PdhGetCounterInfoW().

PdhAddEnglishCounterA()

PDH_STATUS WINAPI PdhAddEnglishCounterA	(	PDH_HQUERY	query,
		LPCSTR	path,
		DWORD_PTR	userdata,
		PDH_HCOUNTER *	counter
	)

Definition at line 277 of file pdh_main.c.

{
    TRACE("%p %s %Ix %p\n", query, debugstr_a(path), userdata, counter);
 
    if (!counter) return PDH_INVALID_ARGUMENT;
    if (!query) return PDH_INVALID_HANDLE;
    return PdhAddCounterA( query, path, userdata, counter );
}

Referenced by init_function_ptrs().

PdhAddEnglishCounterW()

PDH_STATUS WINAPI PdhAddEnglishCounterW	(	PDH_HQUERY	query,
		LPCWSTR	path,
		DWORD_PTR	userdata,
		PDH_HCOUNTER *	counter
	)

Definition at line 290 of file pdh_main.c.

{
    TRACE("%p %s %Ix %p\n", query, debugstr_w(path), userdata, counter);
 
    if (!counter) return PDH_INVALID_ARGUMENT;
    if (!query) return PDH_INVALID_HANDLE;
    return PdhAddCounterW( query, path, userdata, counter );
}

Referenced by init_function_ptrs().

PdhBindInputDataSourceA()

PDH_STATUS WINAPI PdhBindInputDataSourceA	(	PDH_HLOG *	source,
		const char *	filenamelist
	)

Definition at line 1273 of file pdh_main.c.

{
    FIXME("%p %s: stub\n", source, debugstr_a(filenamelist));
    return PDH_NOT_IMPLEMENTED;
}

PdhBindInputDataSourceW()

PDH_STATUS WINAPI PdhBindInputDataSourceW	(	PDH_HLOG *	source,
		const WCHAR *	filenamelist
	)

Definition at line 1282 of file pdh_main.c.

{
    FIXME("%p %s: stub\n", source, debugstr_w(filenamelist));
    return PDH_NOT_IMPLEMENTED;
}

PdhCalculateCounterFromRawValue()

PDH_STATUS WINAPI PdhCalculateCounterFromRawValue	(	PDH_HCOUNTER	handle,
		DWORD	format,
		PPDH_RAW_COUNTER	raw1,
		PPDH_RAW_COUNTER	raw2,
		PPDH_FMT_COUNTERVALUE	value
	)

Definition at line 333 of file pdh_main.c.

{
    PDH_STATUS ret;
    struct counter *counter = handle;
 
    TRACE("%p 0x%08lx %p %p %p\n", handle, format, raw1, raw2, value);
 
    if (!value) return PDH_INVALID_ARGUMENT;
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
 
    ret = format_value( counter, format, (union value *)&raw1->SecondValue,
                                         (union value *)&raw2->SecondValue, value );
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ret;
}

PdhCloseQuery()

PDH_STATUS WINAPI PdhCloseQuery

(

PDH_HQUERY

handle

)

Definition at line 362 of file pdh_main.c.

{
    struct query *query = handle;
    struct list *item, *next;
 
    TRACE("%p\n", handle);
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
 
    if (query->thread)
    {
        HANDLE thread = query->thread;
        SetEvent( query->stop );
        LeaveCriticalSection( &pdh_handle_cs );
 
        WaitForSingleObject( thread, INFINITE );
 
        EnterCriticalSection( &pdh_handle_cs );
        if (query->magic != PDH_MAGIC_QUERY)
        {
            LeaveCriticalSection( &pdh_handle_cs );
            return ERROR_SUCCESS;
        }
        CloseHandle( query->stop );
        CloseHandle( query->thread );
        query->thread = NULL;
    }
 
    LIST_FOR_EACH_SAFE( item, next, &query->counters )
    {
        struct counter *counter = LIST_ENTRY( item, struct counter, entry );
 
        list_remove( &counter->entry );
        destroy_counter( counter );
    }
 
    destroy_query( query );
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), test_PdhAddEnglishCounterW(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterInfoW(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), test_PdhOpenQueryA(), test_PdhOpenQueryW(), test_PdhSetCounterScaleFactor(), and test_PdhVbGetDoubleCounterValue().

PdhCollectQueryData()

PDH_STATUS WINAPI PdhCollectQueryData

(

PDH_HQUERY

handle

)

Definition at line 429 of file pdh_main.c.

{
    struct query *query = handle;
 
    TRACE("%p\n", handle);
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
 
    if (list_empty( &query->counters ))
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_NO_DATA;
    }
 
    collect_query_data( query );
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), test_PdhAddEnglishCounterW(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), and test_PdhVbGetDoubleCounterValue().

PdhCollectQueryDataEx()

PDH_STATUS WINAPI PdhCollectQueryDataEx	(	PDH_HQUERY	handle,
		DWORD	interval,
		HANDLE	event
	)

Definition at line 485 of file pdh_main.c.

{
    PDH_STATUS ret;
    struct query *query = handle;
 
    TRACE("%p %ld %p\n", handle, interval, event);
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (list_empty( &query->counters ))
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_NO_DATA;
    }
    if (query->thread)
    {
        HANDLE thread = query->thread;
        SetEvent( query->stop );
        LeaveCriticalSection( &pdh_handle_cs );
 
        WaitForSingleObject( thread, INFINITE );
 
        EnterCriticalSection( &pdh_handle_cs );
        if (query->magic != PDH_MAGIC_QUERY)
        {
            LeaveCriticalSection( &pdh_handle_cs );
            return PDH_INVALID_HANDLE;
        }
        CloseHandle( query->thread );
        query->thread = NULL;
    }
    else if (!(query->stop = CreateEventW( NULL, FALSE, FALSE, NULL )))
    {
        ret = GetLastError();
        LeaveCriticalSection( &pdh_handle_cs );
        return ret;
    }
    query->wait = event;
    query->interval = interval * 1000;
    if (!(query->thread = CreateThread( NULL, 0, collect_query_thread, query, 0, NULL )))
    {
        ret = GetLastError();
        CloseHandle( query->stop );
 
        LeaveCriticalSection( &pdh_handle_cs );
        return ret;
    }
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhCollectQueryDataEx().

PdhCollectQueryDataWithTime()

PDH_STATUS WINAPI PdhCollectQueryDataWithTime	(	PDH_HQUERY	handle,
		LONGLONG *	timestamp
	)

Definition at line 544 of file pdh_main.c.

{
    struct query *query = handle;
    struct counter *counter;
    struct list *item;
 
    TRACE("%p %p\n", handle, timestamp);
 
    if (!timestamp) return PDH_INVALID_ARGUMENT;
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!query || query->magic != PDH_MAGIC_QUERY)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (list_empty( &query->counters ))
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_NO_DATA;
    }
 
    collect_query_data( query );
 
    item = list_head( &query->counters );
    counter = LIST_ENTRY( item, struct counter, entry );
 
    *timestamp = ((LONGLONG)counter->stamp.dwHighDateTime << 32) | counter->stamp.dwLowDateTime;
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by init_function_ptrs().

PdhConnectMachineA()

PDH_STATUS WINAPI PdhConnectMachineA

(

const char *

name

)

Definition at line 1291 of file pdh_main.c.

{
    FIXME("%s: stub\n", debugstr_a(name));
    return PDH_NOT_IMPLEMENTED;
}

PdhEnumObjectItemsA()

PDH_STATUS WINAPI PdhEnumObjectItemsA	(	LPCSTR	szDataSource,
		LPCSTR	szMachineName,
		LPCSTR	szObjectName,
		LPSTR	mszCounterList,
		LPDWORD	pcchCounterListLength,
		LPSTR	mszInstanceList,
		LPDWORD	pcchInstanceListLength,
		DWORD	dwDetailLevel,
		DWORD	dwFlags
	)

Definition at line 1218 of file pdh_main.c.

{
    FIXME("%s, %s, %s, %p, %p, %p, %p, %ld, 0x%lx: stub\n", debugstr_a(szDataSource), debugstr_a(szMachineName),
         debugstr_a(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
         pcchInstanceListLength, dwDetailLevel, dwFlags);
 
    return PDH_NOT_IMPLEMENTED;
}

PdhEnumObjectItemsW()

PDH_STATUS WINAPI PdhEnumObjectItemsW	(	LPCWSTR	szDataSource,
		LPCWSTR	szMachineName,
		LPCWSTR	szObjectName,
		LPWSTR	mszCounterList,
		LPDWORD	pcchCounterListLength,
		LPWSTR	mszInstanceList,
		LPDWORD	pcchInstanceListLength,
		DWORD	dwDetailLevel,
		DWORD	dwFlags
	)

Definition at line 1232 of file pdh_main.c.

{
    FIXME("%s, %s, %s, %p, %p, %p, %p, %ld, 0x%lx: stub\n", debugstr_w(szDataSource), debugstr_w(szMachineName),
         debugstr_w(szObjectName), mszCounterList, pcchCounterListLength, mszInstanceList,
         pcchInstanceListLength, dwDetailLevel, dwFlags);
 
    return PDH_NOT_IMPLEMENTED;
}

PdhExpandCounterPathA()

PDH_STATUS WINAPI PdhExpandCounterPathA	(	LPCSTR	szWildCardPath,
		LPSTR	mszExpandedPathList,
		LPDWORD	pcchPathListLength
	)

Definition at line 598 of file pdh_main.c.

{
    FIXME("%s, %p, %p: stub\n", debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength);
    return PdhExpandWildCardPathA(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
}

PdhExpandCounterPathW()

PDH_STATUS WINAPI PdhExpandCounterPathW	(	LPCWSTR	szWildCardPath,
		LPWSTR	mszExpandedPathList,
		LPDWORD	pcchPathListLength
	)

Definition at line 607 of file pdh_main.c.

{
    FIXME("%s, %p, %p: stub\n", debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength);
    return PdhExpandWildCardPathW(NULL, szWildCardPath, mszExpandedPathList, pcchPathListLength, 0);
}

PdhExpandWildCardPathA()

PDH_STATUS WINAPI PdhExpandWildCardPathA	(	LPCSTR	szDataSource,
		LPCSTR	szWildCardPath,
		LPSTR	mszExpandedPathList,
		LPDWORD	pcchPathListLength,
		DWORD	dwFlags
	)

Definition at line 580 of file pdh_main.c.

{
    FIXME("%s, %s, %p, %p, 0x%lx: stub\n", debugstr_a(szDataSource), debugstr_a(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
    return PDH_NOT_IMPLEMENTED;
}

Referenced by PdhExpandCounterPathA().

PdhExpandWildCardPathW()

PDH_STATUS WINAPI PdhExpandWildCardPathW	(	LPCWSTR	szDataSource,
		LPCWSTR	szWildCardPath,
		LPWSTR	mszExpandedPathList,
		LPDWORD	pcchPathListLength,
		DWORD	dwFlags
	)

Definition at line 589 of file pdh_main.c.

{
    FIXME("%s, %s, %p, %p, 0x%lx: stub\n", debugstr_w(szDataSource), debugstr_w(szWildCardPath), mszExpandedPathList, pcchPathListLength, dwFlags);
    return PDH_NOT_IMPLEMENTED;
}

Referenced by PdhExpandCounterPathW().

PdhGetCounterInfoA()

PDH_STATUS WINAPI PdhGetCounterInfoA	(	PDH_HCOUNTER	handle,
		BOOLEAN	text,
		LPDWORD	size,
		PPDH_COUNTER_INFO_A	info
	)

Definition at line 616 of file pdh_main.c.

{
    struct counter *counter = handle;
 
    TRACE("%p %d %p %p\n", handle, text, size, info);
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (!size)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_ARGUMENT;
    }
    if (*size < sizeof(PDH_COUNTER_INFO_A))
    {
        *size = sizeof(PDH_COUNTER_INFO_A);
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_MORE_DATA;
    }
 
    memset( info, 0, sizeof(PDH_COUNTER_INFO_A) );
 
    info->dwType          = counter->type;
    info->CStatus         = counter->status;
    info->lScale          = counter->scale;
    info->lDefaultScale   = counter->defaultscale;
    info->dwUserData      = counter->user;
    info->dwQueryUserData = counter->queryuser;
 
    *size = sizeof(PDH_COUNTER_INFO_A);
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterInfoA().

PdhGetCounterInfoW()

PDH_STATUS WINAPI PdhGetCounterInfoW	(	PDH_HCOUNTER	handle,
		BOOLEAN	text,
		LPDWORD	size,
		PPDH_COUNTER_INFO_W	info
	)

Definition at line 658 of file pdh_main.c.

{
    struct counter *counter = handle;
 
    TRACE("%p %d %p %p\n", handle, text, size, info);
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (!size)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_ARGUMENT;
    }
    if (*size < sizeof(PDH_COUNTER_INFO_W))
    {
        *size = sizeof(PDH_COUNTER_INFO_W);
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_MORE_DATA;
    }
 
    memset( info, 0, sizeof(PDH_COUNTER_INFO_W) );
 
    info->dwType          = counter->type;
    info->CStatus         = counter->status;
    info->lScale          = counter->scale;
    info->lDefaultScale   = counter->defaultscale;
    info->dwUserData      = counter->user;
    info->dwQueryUserData = counter->queryuser;
 
    *size = sizeof(PDH_COUNTER_INFO_W);
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterInfoW().

PdhGetCounterTimeBase()

PDH_STATUS WINAPI PdhGetCounterTimeBase	(	PDH_HCOUNTER	handle,
		LONGLONG *	base
	)

Definition at line 700 of file pdh_main.c.

{
    struct counter *counter = handle;
 
    TRACE("%p %p\n", handle, base);
 
    if (!base) return PDH_INVALID_ARGUMENT;
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
 
    *base = counter->base;
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterTimeBase().

PdhGetDllVersion()

PDH_STATUS WINAPI PdhGetDllVersion

(

LPDWORD

version

)

Definition at line 724 of file pdh_main.c.

{
    if (!version)
        return PDH_INVALID_ARGUMENT;
 
    *version = PDH_VERSION;
 
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetDllVersion().

PdhGetFormattedCounterValue()

PDH_STATUS WINAPI PdhGetFormattedCounterValue	(	PDH_HCOUNTER	handle,
		DWORD	format,
		LPDWORD	type,
		PPDH_FMT_COUNTERVALUE	value
	)

Definition at line 737 of file pdh_main.c.

{
    PDH_STATUS ret;
    struct counter *counter = handle;
 
    TRACE("%p %lx %p %p\n", handle, format, type, value);
 
    if (!value) return PDH_INVALID_ARGUMENT;
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (counter->status)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_DATA;
    }
    if (!(ret = format_value( counter, format, &counter->one, &counter->two, value )))
    {
        value->CStatus = ERROR_SUCCESS;
        if (type) *type = counter->type;
    }
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ret;
}

Referenced by PdhVbGetDoubleCounterValue(), test_PdhCollectQueryDataEx(), test_PdhGetFormattedCounterValue(), and test_PdhVbGetDoubleCounterValue().

PdhGetLogFileTypeA()

PDH_STATUS WINAPI PdhGetLogFileTypeA	(	const char *	log,
		DWORD *	type
	)

Definition at line 1255 of file pdh_main.c.

{
    FIXME("%s, %p: stub\n", debugstr_a(log), type);
    return PDH_NOT_IMPLEMENTED;
}

PdhGetLogFileTypeW()

PDH_STATUS WINAPI PdhGetLogFileTypeW	(	const WCHAR *	log,
		DWORD *	type
	)

Definition at line 1264 of file pdh_main.c.

{
    FIXME("%s, %p: stub\n", debugstr_w(log), type);
    return PDH_NOT_IMPLEMENTED;
}

PdhGetRawCounterValue()

PDH_STATUS WINAPI PdhGetRawCounterValue	(	PDH_HCOUNTER	handle,
		LPDWORD	type,
		PPDH_RAW_COUNTER	value
	)

Definition at line 771 of file pdh_main.c.

{
    struct counter *counter = handle;
 
    TRACE("%p %p %p\n", handle, type, value);
 
    if (!value) return PDH_INVALID_ARGUMENT;
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
 
    value->CStatus                  = counter->status;
    value->TimeStamp.dwLowDateTime  = counter->stamp.dwLowDateTime;
    value->TimeStamp.dwHighDateTime = counter->stamp.dwHighDateTime;
    value->FirstValue               = counter->one.largevalue;
    value->SecondValue              = counter->two.largevalue;
    value->MultiCount               = 1; /* FIXME */
 
    if (type) *type = counter->type;
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetRawCounterValue().

PdhLookupPerfIndexByNameA()

PDH_STATUS WINAPI PdhLookupPerfIndexByNameA	(	LPCSTR	machine,
		LPCSTR	name,
		LPDWORD	index
	)

Definition at line 803 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *machineW = NULL;
    WCHAR *nameW;
 
    TRACE("%s %s %p\n", debugstr_a(machine), debugstr_a(name), index);
 
    if (!name) return PDH_INVALID_ARGUMENT;
 
    if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
 
    if (!(nameW = pdh_strdup_aw( name )))
        return PDH_MEMORY_ALLOCATION_FAILURE;
 
    ret = PdhLookupPerfIndexByNameW( machineW, nameW, index );
 
    free( nameW );
    free( machineW );
    return ret;
}

Referenced by test_PdhLookupPerfIndexByNameA().

PdhLookupPerfIndexByNameW()

PDH_STATUS WINAPI PdhLookupPerfIndexByNameW	(	LPCWSTR	machine,
		LPCWSTR	name,
		LPDWORD	index
	)

Definition at line 828 of file pdh_main.c.

{
    unsigned int i;
 
    TRACE("%s %s %p\n", debugstr_w(machine), debugstr_w(name), index);
 
    if (!name || !index) return PDH_INVALID_ARGUMENT;
 
    if (machine)
    {
        FIXME("remote machine not supported\n");
        return PDH_CSTATUS_NO_MACHINE;
    }
    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
    {
        if (pdh_match_path( counter_sources[i].path, name ))
        {
            *index = counter_sources[i].index;
            return ERROR_SUCCESS;
        }
    }
    return PDH_STRING_NOT_FOUND;
}

Referenced by PdhLookupPerfIndexByNameA(), and test_PdhLookupPerfIndexByNameW().

PdhLookupPerfNameByIndexA()

PDH_STATUS WINAPI PdhLookupPerfNameByIndexA	(	LPCSTR	machine,
		DWORD	index,
		LPSTR	buffer,
		LPDWORD	size
	)

Definition at line 855 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *machineW = NULL;
    WCHAR bufferW[PDH_MAX_COUNTER_NAME];
    DWORD sizeW = ARRAY_SIZE(bufferW);
 
    TRACE("%s %ld %p %p\n", debugstr_a(machine), index, buffer, size);
 
    if (!buffer || !size) return PDH_INVALID_ARGUMENT;
 
    if (machine && !(machineW = pdh_strdup_aw( machine ))) return PDH_MEMORY_ALLOCATION_FAILURE;
 
    if (!(ret = PdhLookupPerfNameByIndexW( machineW, index, bufferW, &sizeW )))
    {
        int required = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
 
        if (*size < required) ret = PDH_MORE_DATA;
        else WideCharToMultiByte( CP_ACP, 0, bufferW, -1, buffer, required, NULL, NULL );
        *size = required;
    }
    free( machineW );
    return ret;
}

Referenced by test_PdhLookupPerfNameByIndexA().

PdhLookupPerfNameByIndexW()

PDH_STATUS WINAPI PdhLookupPerfNameByIndexW	(	LPCWSTR	machine,
		DWORD	index,
		LPWSTR	buffer,
		LPDWORD	size
	)

Definition at line 883 of file pdh_main.c.

{
    PDH_STATUS ret;
    unsigned int i;
 
    TRACE("%s %ld %p %p\n", debugstr_w(machine), index, buffer, size);
 
    if (machine)
    {
        FIXME("remote machine not supported\n");
        return PDH_CSTATUS_NO_MACHINE;
    }
 
    if (!buffer || !size) return PDH_INVALID_ARGUMENT;
    if (!index) return ERROR_SUCCESS;
 
    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
    {
        if (counter_sources[i].index == index)
        {
            WCHAR *p = wcsrchr( counter_sources[i].path, '\\' ) + 1;
            unsigned int required = lstrlenW( p ) + 1;
 
            if (*size < required) ret = PDH_MORE_DATA;
            else
            {
                lstrcpyW( buffer, p );
                ret = ERROR_SUCCESS;
            }
            *size = required;
            return ret;
        }
    }
    return PDH_INVALID_ARGUMENT;
}

Referenced by PdhLookupPerfNameByIndexA(), and test_PdhLookupPerfNameByIndexW().

PdhMakeCounterPathA()

PDH_STATUS WINAPI PdhMakeCounterPathA	(	PDH_COUNTER_PATH_ELEMENTS_A *	e,
		LPSTR	buffer,
		LPDWORD	buflen,
		DWORD	flags
	)

Definition at line 1119 of file pdh_main.c.

{
    PDH_STATUS ret = PDH_MEMORY_ALLOCATION_FAILURE;
    PDH_COUNTER_PATH_ELEMENTS_W eW;
    WCHAR *bufferW;
    DWORD buflenW;
 
    TRACE("%p %p %p 0x%08lx\n", e, buffer, buflen, flags);
 
    if (!e || !buflen) return PDH_INVALID_ARGUMENT;
 
    memset( &eW, 0, sizeof(eW) );
    if (e->szMachineName    && !(eW.szMachineName    = pdh_strdup_aw( e->szMachineName ))) goto done;
    if (e->szObjectName     && !(eW.szObjectName     = pdh_strdup_aw( e->szObjectName ))) goto done;
    if (e->szInstanceName   && !(eW.szInstanceName   = pdh_strdup_aw( e->szInstanceName ))) goto done;
    if (e->szParentInstance && !(eW.szParentInstance = pdh_strdup_aw( e->szParentInstance ))) goto done;
    if (e->szCounterName    && !(eW.szCounterName    = pdh_strdup_aw( e->szCounterName ))) goto done;
    eW.dwInstanceIndex = e->dwInstanceIndex;
 
    buflenW = 0;
    ret = PdhMakeCounterPathW( &eW, NULL, &buflenW, flags );
    if (ret == PDH_MORE_DATA)
    {
        if ((bufferW = malloc( buflenW * sizeof(WCHAR) )))
        {
            if (!(ret = PdhMakeCounterPathW( &eW, bufferW, &buflenW, flags )))
            {
                int len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
                if (*buflen >= len) WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, *buflen, NULL, NULL);
                else ret = PDH_MORE_DATA;
                *buflen = len;
            }
            free( bufferW );
        }
        else
            ret = PDH_MEMORY_ALLOCATION_FAILURE;
    }
 
done:
    free( eW.szMachineName );
    free( eW.szObjectName );
    free( eW.szInstanceName );
    free( eW.szParentInstance );
    free( eW.szCounterName );
    return ret;
}

Referenced by test_PdhMakeCounterPathA().

PdhMakeCounterPathW()

PDH_STATUS WINAPI PdhMakeCounterPathW	(	PDH_COUNTER_PATH_ELEMENTS_W *	e,
		LPWSTR	buffer,
		LPDWORD	buflen,
		DWORD	flags
	)

Definition at line 1170 of file pdh_main.c.

{
    WCHAR path[PDH_MAX_COUNTER_NAME], instance[12];
    PDH_STATUS ret = ERROR_SUCCESS;
    DWORD len;
 
    TRACE("%p %p %p 0x%08lx\n", e, buffer, buflen, flags);
 
    if (flags) FIXME("unimplemented flags 0x%08lx\n", flags);
 
    if (!e || !e->szCounterName || !e->szObjectName || !buflen)
        return PDH_INVALID_ARGUMENT;
 
    path[0] = 0;
    if (e->szMachineName)
    {
        lstrcatW(path, L"\\\\");
        lstrcatW(path, e->szMachineName);
    }
    lstrcatW(path, L"\\");
    lstrcatW(path, e->szObjectName);
    if (e->szInstanceName)
    {
        lstrcatW(path, L"(");
        if (e->szParentInstance)
        {
            lstrcatW(path, e->szParentInstance);
            lstrcatW(path, L"/");
        }
        lstrcatW(path, e->szInstanceName);
        swprintf(instance, ARRAY_SIZE(instance), L"#%u", e->dwInstanceIndex);
        lstrcatW(path, instance);
        lstrcatW(path, L")");
    }
    lstrcatW(path, L"\\");
    lstrcatW(path, e->szCounterName);
 
    len = lstrlenW(path) + 1;
    if (*buflen >= len) lstrcpyW(buffer, path);
    else ret = PDH_MORE_DATA;
    *buflen = len;
    return ret;
}

Referenced by PdhMakeCounterPathA().

PdhOpenQueryA()

PDH_STATUS WINAPI PdhOpenQueryA	(	LPCSTR	source,
		DWORD_PTR	userdata,
		PDH_HQUERY *	query
	)

Definition at line 922 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *sourceW = NULL;
 
    TRACE("%s %Ix %p\n", debugstr_a(source), userdata, query);
 
    if (source && !(sourceW = pdh_strdup_aw( source ))) return PDH_MEMORY_ALLOCATION_FAILURE;
 
    ret = PdhOpenQueryW( sourceW, userdata, query );
    free( sourceW );
 
    return ret;
}

Referenced by test_PdhAddCounterA(), test_PdhAddEnglishCounterA(), test_PdhCollectQueryDataEx(), test_PdhCollectQueryDataWithTime(), test_PdhGetCounterInfoA(), test_PdhGetCounterTimeBase(), test_PdhGetFormattedCounterValue(), test_PdhGetRawCounterValue(), test_PdhOpenQueryA(), test_PdhSetCounterScaleFactor(), and test_PdhVbGetDoubleCounterValue().

PdhOpenQueryW()

PDH_STATUS WINAPI PdhOpenQueryW	(	LPCWSTR	source,
		DWORD_PTR	userdata,
		PDH_HQUERY *	handle
	)

Definition at line 940 of file pdh_main.c.

{
    struct query *query;
 
    TRACE("%s %Ix %p\n", debugstr_w(source), userdata, handle);
 
    if (!handle) return PDH_INVALID_ARGUMENT;
 
    if (source)
    {
        FIXME("log file data source not supported\n");
        return PDH_INVALID_ARGUMENT;
    }
    if ((query = create_query()))
    {
        query->user = userdata;
        *handle = query;
 
        return ERROR_SUCCESS;
    }
    return PDH_MEMORY_ALLOCATION_FAILURE;
}

Referenced by PdhOpenQueryA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterW(), test_PdhGetCounterInfoW(), and test_PdhOpenQueryW().

PdhRemoveCounter()

PDH_STATUS WINAPI PdhRemoveCounter

(

PDH_HCOUNTER

handle

)

Definition at line 966 of file pdh_main.c.

{
    struct counter *counter = handle;
 
    TRACE("%p\n", handle);
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
 
    list_remove( &counter->entry );
    destroy_counter( counter );
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhAddCounterA(), test_PdhAddCounterW(), test_PdhAddEnglishCounterA(), and test_PdhAddEnglishCounterW().

PdhSetCounterScaleFactor()

PDH_STATUS WINAPI PdhSetCounterScaleFactor	(	PDH_HCOUNTER	handle,
		LONG	factor
	)

Definition at line 989 of file pdh_main.c.

{
    struct counter *counter = handle;
 
    TRACE("%p\n", handle);
 
    EnterCriticalSection( &pdh_handle_cs );
    if (!counter || counter->magic != PDH_MAGIC_COUNTER)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_HANDLE;
    }
    if (factor < PDH_MIN_SCALE || factor > PDH_MAX_SCALE)
    {
        LeaveCriticalSection( &pdh_handle_cs );
        return PDH_INVALID_ARGUMENT;
    }
 
    counter->scale = factor;
 
    LeaveCriticalSection( &pdh_handle_cs );
    return ERROR_SUCCESS;
}

Referenced by test_PdhGetCounterInfoA(), test_PdhGetCounterInfoW(), test_PdhGetFormattedCounterValue(), and test_PdhSetCounterScaleFactor().

PdhSetDefaultRealTimeDataSource()

PDH_STATUS WINAPI PdhSetDefaultRealTimeDataSource

(

DWORD

source

)

Definition at line 1246 of file pdh_main.c.

{
    FIXME("%lu\n", source);
    return ERROR_SUCCESS;
}

PdhValidatePathA()

PDH_STATUS WINAPI PdhValidatePathA

(

LPCSTR

path

)

Definition at line 1016 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *pathW;
 
    TRACE("%s\n", debugstr_a(path));
 
    if (!path) return PDH_INVALID_ARGUMENT;
    if (!(pathW = pdh_strdup_aw( path ))) return PDH_MEMORY_ALLOCATION_FAILURE;
 
    ret = PdhValidatePathW( pathW );
 
    free( pathW );
    return ret;
}

Referenced by PdhValidatePathExA(), and test_PdhValidatePathA().

PdhValidatePathExA()

PDH_STATUS WINAPI PdhValidatePathExA	(	PDH_HLOG	source,
		LPCSTR	path
	)

Definition at line 1089 of file pdh_main.c.

{
    TRACE("%p %s\n", source, debugstr_a(path));
 
    if (source)
    {
        FIXME("log file data source not supported\n");
        return ERROR_SUCCESS;
    }
    return PdhValidatePathA( path );
}

Referenced by init_function_ptrs().

PdhValidatePathExW()

PDH_STATUS WINAPI PdhValidatePathExW	(	PDH_HLOG	source,
		LPCWSTR	path
	)

Definition at line 1104 of file pdh_main.c.

{
    TRACE("%p %s\n", source, debugstr_w(path));
 
    if (source)
    {
        FIXME("log file data source not supported\n");
        return ERROR_SUCCESS;
    }
    return PdhValidatePathW( path );
}

Referenced by init_function_ptrs().

PdhValidatePathW()

PDH_STATUS WINAPI PdhValidatePathW

(

LPCWSTR

path

)

Definition at line 1042 of file pdh_main.c.

{
    PDH_STATUS ret;
    unsigned int i;
 
    TRACE("%s\n", debugstr_w(path));
 
    if ((ret = validate_path( path ))) return ret;
 
    for (i = 0; i < ARRAY_SIZE(counter_sources); i++)
        if (pdh_match_path( counter_sources[i].path, path )) return ERROR_SUCCESS;
 
    return PDH_CSTATUS_NO_COUNTER;
}

Referenced by PdhValidatePathA(), PdhValidatePathExW(), and test_PdhValidatePathW().

PdhVbAddCounter()

PDH_STATUS WINAPI PdhVbAddCounter	(	PDH_HQUERY	query,
		LPCSTR	path,
		PDH_HCOUNTER *	counter
	)

Definition at line 1060 of file pdh_main.c.

{
    FIXME("%p, %s, %p: stub!\n", query, debugstr_a(path), counter);
 
    if (!path) return PDH_INVALID_ARGUMENT;
 
    return PDH_NOT_IMPLEMENTED;
}

PdhVbGetDoubleCounterValue()

double WINAPI PdhVbGetDoubleCounterValue	(	PDH_HCOUNTER	handle,
		PDH_STATUS *	counter_status
	)

Definition at line 1072 of file pdh_main.c.

{
    PDH_FMT_COUNTERVALUE value;
    PDH_STATUS status;
 
    TRACE( "%p %p\n", handle, counter_status );
 
    memset( &value, 0, sizeof(value) );
    status = PdhGetFormattedCounterValue( handle, PDH_FMT_DOUBLE, NULL, &value );
 
    if (counter_status) *counter_status = status;
    return value.doubleValue;
}

Referenced by init_function_ptrs().

validate_path()

static PDH_STATUS validate_path ( LPCWSTR  path )

static

Definition at line 1032 of file pdh_main.c.

{
    if (!path || !*path) return PDH_INVALID_ARGUMENT;
    if (*path++ != '\\' || !wcschr( path, '\\' )) return PDH_CSTATUS_BAD_COUNTERNAME;
    return ERROR_SUCCESS;
 }

Referenced by PdhValidatePathW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

pdh

)

Variable Documentation

counter_sources

const struct source counter_sources[]

static

Initial value:

=
{
    { 6,   L"\\Processor(_Total)\\% Processor Time", collect_processor_time, TYPE_PROCESSOR_TIME, -5, 10000000 },
    { 674, L"\\System\\System Up Time",              collect_uptime,         TYPE_UPTIME,         -3, 1000 }
}

Definition at line 173 of file pdh_main.c.

Referenced by PdhAddCounterW(), PdhLookupPerfIndexByNameW(), PdhLookupPerfNameByIndexW(), and PdhValidatePathW().

pdh_handle_cs

static CRITICAL_SECTION pdh_handle_cs = { &pdh_handle_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 42 of file pdh_main.c.

Referenced by collect_query_thread(), PdhAddCounterW(), PdhCalculateCounterFromRawValue(), PdhCloseQuery(), PdhCollectQueryData(), PdhCollectQueryDataEx(), PdhCollectQueryDataWithTime(), PdhGetCounterInfoA(), PdhGetCounterInfoW(), PdhGetCounterTimeBase(), PdhGetFormattedCounterValue(), PdhGetRawCounterValue(), PdhRemoveCounter(), and PdhSetCounterScaleFactor().

pdh_handle_cs_debug

CRITICAL_SECTION_DEBUG pdh_handle_cs_debug

static

Initial value:

=
{
    0, 0, &pdh_handle_cs,
    { &pdh_handle_cs_debug.ProcessLocksList,
      &pdh_handle_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": pdh_handle_cs") }
}

Definition at line 43 of file pdh_main.c.