pdh.h File Reference

#include <windows.h>
#include <winperf.h>

Include dependency graph for pdh.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PDH_FMT_COUNTERVALUE
struct	_PDH_RAW_COUNTER
struct	_PDH_COUNTER_PATH_ELEMENTS_A
struct	_PDH_COUNTER_PATH_ELEMENTS_W
struct	_PDH_DATA_ITEM_PATH_ELEMENTS_A
struct	_PDH_DATA_ITEM_PATH_ELEMENTS_W
struct	_PDH_COUNTER_INFO_A
struct	_PDH_COUNTER_INFO_W

Macros
#define	PDH_CVERSION_WIN40   0x0400
#define	PDH_CVERSION_WIN50   0x0500
#define	PDH_VERSION   0x0503
#define	PDH_MAX_SCALE   7
#define	PDH_MIN_SCALE   (-7)
#define	PDH_MAX_COUNTER_NAME   1024
#define	PDH_FMT_LONG   0x00000100
#define	PDH_FMT_DOUBLE   0x00000200
#define	PDH_FMT_LARGE   0x00000400
#define	PDH_FMT_NOSCALE   0x00001000
#define	PDH_FMT_1000   0x00002000
#define	PDH_FMT_NOCAP100   0x00008000
#define	DATA_SOURCE_REGISTRY   0x00000001
#define	DATA_SOURCE_LOGFILE   0x00000002
#define	DATA_SOURCE_WBEM   0x00000004
#define	PdhAddCounter   WINELIB_NAME_AW(PdhAddCounter)
#define	PdhAddEnglishCounter   WINELIB_NAME_AW(PdhAddEnglishCounter)
#define	PdhEnumObjectItems   WINELIB_NAME_AW(PdhEnumObjectItems)
#define	PdhGetCounterInfo   WINELIB_NAME_AW(PdhGetCounterInfo)
#define	PdhLookupPerfIndexByName   WINELIB_NAME_AW(PdhLookupPerfIndexByName)
#define	PdhLookupPerfNameByIndex   WINELIB_NAME_AW(PdhLookupPerfNameByIndex)
#define	PdhMakeCounterPath   WINELIB_NAME_AW(PdhMakeCounterPath)
#define	PdhOpenQuery   WINELIB_NAME_AW(PdhOpenQuery)
#define	PdhValidatePath   WINELIB_NAME_AW(PdhValidatePath)
#define	PdhValidatePathEx   WINELIB_NAME_AW(PdhValidatePathEx)

Typedefs
typedef LONG	PDH_STATUS
typedef HANDLE	PDH_HQUERY
typedef HANDLE	PDH_HCOUNTER
typedef HANDLE	PDH_HLOG
typedef struct _PDH_FMT_COUNTERVALUE	PDH_FMT_COUNTERVALUE
typedef struct _PDH_FMT_COUNTERVALUE *	PPDH_FMT_COUNTERVALUE
typedef struct _PDH_RAW_COUNTER	PDH_RAW_COUNTER
typedef struct _PDH_RAW_COUNTER *	PPDH_RAW_COUNTER
typedef struct _PDH_COUNTER_PATH_ELEMENTS_A	PDH_COUNTER_PATH_ELEMENTS_A
typedef struct _PDH_COUNTER_PATH_ELEMENTS_A *	PPDH_COUNTER_PATH_ELEMENTS_A
typedef struct _PDH_COUNTER_PATH_ELEMENTS_W	PDH_COUNTER_PATH_ELEMENTS_W
typedef struct _PDH_COUNTER_PATH_ELEMENTS_W *	PPDH_COUNTER_PATH_ELEMENTS_W
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A	PDH_DATA_ITEM_PATH_ELEMENTS_A
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A *	PPDH_DATA_ITEM_PATH_ELEMENTS_A
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W	PDH_DATA_ITEM_PATH_ELEMENTS_W
typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W *	PPDH_DATA_ITEM_PATH_ELEMENTS_W
typedef struct _PDH_COUNTER_INFO_A	PDH_COUNTER_INFO_A
typedef struct _PDH_COUNTER_INFO_A *	PPDH_COUNTER_INFO_A
typedef struct _PDH_COUNTER_INFO_W	PDH_COUNTER_INFO_W
typedef struct _PDH_COUNTER_INFO_W *	PPDH_COUNTER_INFO_W

Functions
PDH_STATUS WINAPI	PdhAddCounterA (PDH_HQUERY, LPCSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhAddCounterW (PDH_HQUERY, LPCWSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhAddEnglishCounterA (PDH_HQUERY, LPCSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhAddEnglishCounterW (PDH_HQUERY, LPCWSTR, DWORD_PTR, PDH_HCOUNTER *)
PDH_STATUS WINAPI	PdhCloseQuery (PDH_HQUERY)
PDH_STATUS WINAPI	PdhCollectQueryData (PDH_HQUERY)
PDH_STATUS WINAPI	PdhCollectQueryDataEx (PDH_HQUERY, DWORD, HANDLE)
PDH_STATUS WINAPI	PdhCollectQueryDataWithTime (PDH_HQUERY, LONGLONG *)
PDH_STATUS WINAPI	PdhEnumObjectItemsA (LPCSTR, LPCSTR, LPCSTR, LPSTR, LPDWORD, LPSTR, LPDWORD, DWORD, DWORD)
PDH_STATUS WINAPI	PdhEnumObjectItemsW (LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, LPDWORD, LPWSTR, LPDWORD, DWORD, DWORD)
PDH_STATUS WINAPI	PdhGetCounterInfoA (PDH_HCOUNTER, BOOLEAN, LPDWORD, PPDH_COUNTER_INFO_A)
PDH_STATUS WINAPI	PdhGetCounterInfoW (PDH_HCOUNTER, BOOLEAN, LPDWORD, PPDH_COUNTER_INFO_W)
PDH_STATUS WINAPI	PdhGetCounterTimeBase (PDH_HCOUNTER, LONGLONG *)
PDH_STATUS WINAPI	PdhGetDllVersion (LPDWORD)
PDH_STATUS WINAPI	PdhGetFormattedCounterValue (PDH_HCOUNTER, DWORD, LPDWORD, PPDH_FMT_COUNTERVALUE)
PDH_STATUS WINAPI	PdhGetRawCounterValue (PDH_HCOUNTER, LPDWORD, PPDH_RAW_COUNTER)
PDH_STATUS WINAPI	PdhLookupPerfIndexByNameA (LPCSTR, LPCSTR, LPDWORD)
PDH_STATUS WINAPI	PdhLookupPerfIndexByNameW (LPCWSTR, LPCWSTR, LPDWORD)
PDH_STATUS WINAPI	PdhLookupPerfNameByIndexA (LPCSTR, DWORD, LPSTR, LPDWORD)
PDH_STATUS WINAPI	PdhLookupPerfNameByIndexW (LPCWSTR, DWORD, LPWSTR, LPDWORD)
PDH_STATUS WINAPI	PdhMakeCounterPathA (PDH_COUNTER_PATH_ELEMENTS_A *, LPSTR, LPDWORD, DWORD)
PDH_STATUS WINAPI	PdhMakeCounterPathW (PDH_COUNTER_PATH_ELEMENTS_W *, LPWSTR, LPDWORD, DWORD)
PDH_STATUS WINAPI	PdhOpenQueryA (LPCSTR, DWORD_PTR, PDH_HQUERY *)
PDH_STATUS WINAPI	PdhOpenQueryW (LPCWSTR, DWORD_PTR, PDH_HQUERY *)
PDH_STATUS WINAPI	PdhRemoveCounter (PDH_HCOUNTER)
PDH_STATUS WINAPI	PdhSetCounterScaleFactor (PDH_HCOUNTER, LONG)
PDH_STATUS WINAPI	PdhSetDefaultRealTimeDataSource (DWORD)
PDH_STATUS WINAPI	PdhValidatePathA (LPCSTR)
PDH_STATUS WINAPI	PdhValidatePathW (LPCWSTR)
PDH_STATUS WINAPI	PdhValidatePathExA (PDH_HLOG, LPCSTR)
PDH_STATUS WINAPI	PdhValidatePathExW (PDH_HLOG, LPCWSTR)

Macro Definition Documentation

DATA_SOURCE_LOGFILE

#define DATA_SOURCE_LOGFILE   0x00000002

Definition at line 57 of file pdh.h.

DATA_SOURCE_REGISTRY

#define DATA_SOURCE_REGISTRY   0x00000001

Definition at line 56 of file pdh.h.

DATA_SOURCE_WBEM

#define DATA_SOURCE_WBEM   0x00000004

Definition at line 58 of file pdh.h.

PDH_CVERSION_WIN40

#define PDH_CVERSION_WIN40   0x0400

Definition at line 40 of file pdh.h.

PDH_CVERSION_WIN50

#define PDH_CVERSION_WIN50   0x0500

Definition at line 41 of file pdh.h.

PDH_FMT_1000

#define PDH_FMT_1000   0x00002000

Definition at line 53 of file pdh.h.

PDH_FMT_DOUBLE

#define PDH_FMT_DOUBLE   0x00000200

Definition at line 50 of file pdh.h.

PDH_FMT_LARGE

#define PDH_FMT_LARGE   0x00000400

Definition at line 51 of file pdh.h.

PDH_FMT_LONG

#define PDH_FMT_LONG   0x00000100

Definition at line 49 of file pdh.h.

PDH_FMT_NOCAP100

#define PDH_FMT_NOCAP100   0x00008000

Definition at line 54 of file pdh.h.

PDH_FMT_NOSCALE

#define PDH_FMT_NOSCALE   0x00001000

Definition at line 52 of file pdh.h.

PDH_MAX_COUNTER_NAME

#define PDH_MAX_COUNTER_NAME   1024

Definition at line 47 of file pdh.h.

PDH_MAX_SCALE

#define PDH_MAX_SCALE   7

Definition at line 44 of file pdh.h.

PDH_MIN_SCALE

#define PDH_MIN_SCALE   (-7)

Definition at line 45 of file pdh.h.

PDH_VERSION

#define PDH_VERSION   0x0503

Definition at line 42 of file pdh.h.

PdhAddCounter

#define PdhAddCounter   WINELIB_NAME_AW(PdhAddCounter)

Definition at line 178 of file pdh.h.

PdhAddEnglishCounter

#define PdhAddEnglishCounter   WINELIB_NAME_AW(PdhAddEnglishCounter)

Definition at line 181 of file pdh.h.

PdhEnumObjectItems

#define PdhEnumObjectItems   WINELIB_NAME_AW(PdhEnumObjectItems)

Definition at line 188 of file pdh.h.

PdhGetCounterInfo

#define PdhGetCounterInfo   WINELIB_NAME_AW(PdhGetCounterInfo)

Definition at line 191 of file pdh.h.

PdhLookupPerfIndexByName

#define PdhLookupPerfIndexByName   WINELIB_NAME_AW(PdhLookupPerfIndexByName)

Definition at line 198 of file pdh.h.

PdhLookupPerfNameByIndex

#define PdhLookupPerfNameByIndex   WINELIB_NAME_AW(PdhLookupPerfNameByIndex)

Definition at line 201 of file pdh.h.

PdhMakeCounterPath

#define PdhMakeCounterPath   WINELIB_NAME_AW(PdhMakeCounterPath)

Definition at line 204 of file pdh.h.

PdhOpenQuery

#define PdhOpenQuery   WINELIB_NAME_AW(PdhOpenQuery)

Definition at line 207 of file pdh.h.

PdhValidatePath

#define PdhValidatePath   WINELIB_NAME_AW(PdhValidatePath)

Definition at line 213 of file pdh.h.

PdhValidatePathEx

#define PdhValidatePathEx   WINELIB_NAME_AW(PdhValidatePathEx)

Definition at line 216 of file pdh.h.

Typedef Documentation

PDH_COUNTER_INFO_A

typedef struct _PDH_COUNTER_INFO_A PDH_COUNTER_INFO_A

PDH_COUNTER_INFO_W

typedef struct _PDH_COUNTER_INFO_W PDH_COUNTER_INFO_W

PDH_COUNTER_PATH_ELEMENTS_A

typedef struct _PDH_COUNTER_PATH_ELEMENTS_A PDH_COUNTER_PATH_ELEMENTS_A

PDH_COUNTER_PATH_ELEMENTS_W

typedef struct _PDH_COUNTER_PATH_ELEMENTS_W PDH_COUNTER_PATH_ELEMENTS_W

PDH_DATA_ITEM_PATH_ELEMENTS_A

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A PDH_DATA_ITEM_PATH_ELEMENTS_A

PDH_DATA_ITEM_PATH_ELEMENTS_W

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W PDH_DATA_ITEM_PATH_ELEMENTS_W

PDH_FMT_COUNTERVALUE

typedef struct _PDH_FMT_COUNTERVALUE PDH_FMT_COUNTERVALUE

PDH_HCOUNTER

typedef HANDLE PDH_HCOUNTER

Definition at line 37 of file pdh.h.

PDH_HLOG

typedef HANDLE PDH_HLOG

Definition at line 38 of file pdh.h.

PDH_HQUERY

typedef HANDLE PDH_HQUERY

Definition at line 36 of file pdh.h.

PDH_RAW_COUNTER

typedef struct _PDH_RAW_COUNTER PDH_RAW_COUNTER

PDH_STATUS

static PDH_STATUS

Definition at line 35 of file pdh.h.

PPDH_COUNTER_INFO_A

typedef struct _PDH_COUNTER_INFO_A * PPDH_COUNTER_INFO_A

PPDH_COUNTER_INFO_W

typedef struct _PDH_COUNTER_INFO_W * PPDH_COUNTER_INFO_W

PPDH_COUNTER_PATH_ELEMENTS_A

typedef struct _PDH_COUNTER_PATH_ELEMENTS_A * PPDH_COUNTER_PATH_ELEMENTS_A

PPDH_COUNTER_PATH_ELEMENTS_W

typedef struct _PDH_COUNTER_PATH_ELEMENTS_W * PPDH_COUNTER_PATH_ELEMENTS_W

PPDH_DATA_ITEM_PATH_ELEMENTS_A

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_A * PPDH_DATA_ITEM_PATH_ELEMENTS_A

PPDH_DATA_ITEM_PATH_ELEMENTS_W

typedef struct _PDH_DATA_ITEM_PATH_ELEMENTS_W * PPDH_DATA_ITEM_PATH_ELEMENTS_W

PPDH_FMT_COUNTERVALUE

typedef struct _PDH_FMT_COUNTERVALUE * PPDH_FMT_COUNTERVALUE

PPDH_RAW_COUNTER

typedef struct _PDH_RAW_COUNTER * PPDH_RAW_COUNTER

Function Documentation

PdhAddCounterA()

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

Definition at line 244 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *pathW;
 
    TRACE("%p %s %lx %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 );
 
    heap_free( pathW );
    return ret;
}

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

PdhAddCounterW()

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

Definition at line 266 of file pdh_main.c.

{
    struct query *query = hquery;
    struct counter *counter;
    unsigned int i;
 
    TRACE("%p %s %lx %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         = pdh_strdup( 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 316 of file pdh_main.c.

{
    TRACE("%p %s %lx %p\n", query, debugstr_a(path), userdata, counter);
 
    if (!query) return PDH_INVALID_ARGUMENT;
    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 328 of file pdh_main.c.

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

Referenced by init_function_ptrs().

PdhCloseQuery()

PDH_STATUS WINAPI PdhCloseQuery

(

PDH_HQUERY

handle

)

Definition at line 399 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(), and test_PdhSetCounterScaleFactor().

PdhCollectQueryData()

PDH_STATUS WINAPI PdhCollectQueryData

(

PDH_HQUERY

handle

)

Definition at line 466 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(), and test_PdhGetRawCounterValue().

PdhCollectQueryDataEx()

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

Definition at line 522 of file pdh_main.c.

{
    PDH_STATUS ret;
    struct query *query = handle;
 
    TRACE("%p %d %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 581 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().

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 1245 of file pdh_main.c.

{
    FIXME("%s, %s, %s, %p, %p, %p, %p, %d, 0x%x: 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 1259 of file pdh_main.c.

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

PdhGetCounterInfoA()

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

Definition at line 653 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 695 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 737 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 761 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 774 of file pdh_main.c.

{
    PDH_STATUS ret;
    struct counter *counter = handle;
 
    TRACE("%p %x %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 test_PdhCollectQueryDataEx(), and test_PdhGetFormattedCounterValue().

PdhGetRawCounterValue()

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

Definition at line 808 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 840 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 );
 
    heap_free( nameW );
    heap_free( machineW );
    return ret;
}

Referenced by test_PdhLookupPerfIndexByNameA().

PdhLookupPerfIndexByNameW()

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

Definition at line 865 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 892 of file pdh_main.c.

{
    PDH_STATUS ret;
    WCHAR *machineW = NULL;
    WCHAR bufferW[PDH_MAX_COUNTER_NAME];
    DWORD sizeW = ARRAY_SIZE(bufferW);
 
    TRACE("%s %d %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;
    }
    heap_free( machineW );
    return ret;
}

Referenced by test_PdhLookupPerfNameByIndexA().

PdhLookupPerfNameByIndexW()

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

Definition at line 920 of file pdh_main.c.

{
    PDH_STATUS ret;
    unsigned int i;
 
    TRACE("%s %d %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 1139 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%08x\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 = heap_alloc( 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;
            }
            heap_free( bufferW );
        }
        else
            ret = PDH_MEMORY_ALLOCATION_FAILURE;
    }
 
done:
    heap_free( eW.szMachineName );
    heap_free( eW.szObjectName );
    heap_free( eW.szInstanceName );
    heap_free( eW.szParentInstance );
    heap_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 1190 of file pdh_main.c.

{
    static const WCHAR bslash[] = {'\\',0};
    static const WCHAR fslash[] = {'/',0};
    static const WCHAR lparen[] = {'(',0};
    static const WCHAR rparen[] = {')',0};
    static const WCHAR fmt[]    = {'#','%','u',0};
 
    WCHAR path[PDH_MAX_COUNTER_NAME], instance[12];
    PDH_STATUS ret = ERROR_SUCCESS;
    DWORD len;
 
    TRACE("%p %p %p 0x%08x\n", e, buffer, buflen, flags);
 
    if (flags) FIXME("unimplemented flags 0x%08x\n", flags);
 
    if (!e || !e->szCounterName || !e->szObjectName || !buflen)
        return PDH_INVALID_ARGUMENT;
 
    path[0] = 0;
    if (e->szMachineName)
    {
        lstrcatW(path, bslash);
        lstrcatW(path, bslash);
        lstrcatW(path, e->szMachineName);
    }
    lstrcatW(path, bslash);
    lstrcatW(path, e->szObjectName);
    if (e->szInstanceName)
    {
        lstrcatW(path, lparen);
        if (e->szParentInstance)
        {
            lstrcatW(path, e->szParentInstance);
            lstrcatW(path, fslash);
        }
        lstrcatW(path, e->szInstanceName);
        swprintf(instance, fmt, e->dwInstanceIndex);
        lstrcatW(path, instance);
        lstrcatW(path, rparen);
    }
    lstrcatW(path, bslash);
    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 959 of file pdh_main.c.

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

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

PdhOpenQueryW()

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

Definition at line 977 of file pdh_main.c.

{
    struct query *query;
 
    TRACE("%s %lx %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 1003 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 1026 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 1273 of file pdh_main.c.

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

PdhValidatePathA()

PDH_STATUS WINAPI PdhValidatePathA

(

LPCSTR

path

)

Definition at line 1053 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 );
 
    heap_free( pathW );
    return ret;
}

Referenced by PdhValidatePathExA(), and test_PdhValidatePathA().

PdhValidatePathExA()

PDH_STATUS WINAPI PdhValidatePathExA	(	PDH_HLOG	source,
		LPCSTR	path
	)

Definition at line 1109 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 1124 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 1079 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().