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

Include dependency graph for pdh.h:

This graph shows which files directly or indirectly include 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 242 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 264 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 314 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 326 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 397 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 464 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 520 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 579 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 1243 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 1257 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 651 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 693 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 735 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 759 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 772 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 806 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 838 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 863 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 890 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 918 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 1137 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 1188 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 957 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 975 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 1001 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 1024 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 1271 of file pdh_main.c.

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

◆ PdhValidatePathA()

PDH_STATUS WINAPI PdhValidatePathA ( LPCSTR path )

Definition at line 1051 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 1107 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 1122 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 1077 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().

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ DATA_SOURCE_LOGFILE

◆ DATA_SOURCE_REGISTRY

◆ DATA_SOURCE_WBEM

◆ PDH_CVERSION_WIN40

◆ PDH_CVERSION_WIN50

◆ PDH_FMT_1000

◆ PDH_FMT_DOUBLE

◆ PDH_FMT_LARGE

◆ PDH_FMT_LONG

◆ PDH_FMT_NOCAP100

◆ PDH_FMT_NOSCALE

◆ PDH_MAX_COUNTER_NAME

◆ PDH_MAX_SCALE

◆ PDH_MIN_SCALE

◆ PDH_VERSION

◆ PdhAddCounter

◆ PdhAddEnglishCounter

◆ PdhEnumObjectItems

◆ PdhGetCounterInfo

◆ PdhLookupPerfIndexByName

◆ PdhLookupPerfNameByIndex

◆ PdhMakeCounterPath

◆ PdhOpenQuery

◆ PdhValidatePath

◆ PdhValidatePathEx

Typedef Documentation

◆ PDH_COUNTER_INFO_A

◆ PDH_COUNTER_INFO_W

◆ PDH_COUNTER_PATH_ELEMENTS_A

◆ PDH_COUNTER_PATH_ELEMENTS_W

◆ PDH_DATA_ITEM_PATH_ELEMENTS_A

◆ PDH_DATA_ITEM_PATH_ELEMENTS_W

◆ PDH_FMT_COUNTERVALUE

◆ PDH_HCOUNTER

◆ PDH_HLOG

◆ PDH_HQUERY

◆ PDH_RAW_COUNTER

◆ PDH_STATUS

◆ PPDH_COUNTER_INFO_A

◆ PPDH_COUNTER_INFO_W

◆ PPDH_COUNTER_PATH_ELEMENTS_A

◆ PPDH_COUNTER_PATH_ELEMENTS_W

◆ PPDH_DATA_ITEM_PATH_ELEMENTS_A

◆ PPDH_DATA_ITEM_PATH_ELEMENTS_W

◆ PPDH_FMT_COUNTERVALUE

◆ PPDH_RAW_COUNTER

Function Documentation

◆ PdhAddCounterA()

◆ PdhAddCounterW()

◆ PdhAddEnglishCounterA()

◆ PdhAddEnglishCounterW()

◆ PdhCloseQuery()

◆ PdhCollectQueryData()

◆ PdhCollectQueryDataEx()

◆ PdhCollectQueryDataWithTime()

◆ PdhEnumObjectItemsA()

◆ PdhEnumObjectItemsW()

◆ PdhGetCounterInfoA()

◆ PdhGetCounterInfoW()

◆ PdhGetCounterTimeBase()

◆ PdhGetDllVersion()

◆ PdhGetFormattedCounterValue()

◆ PdhGetRawCounterValue()

◆ PdhLookupPerfIndexByNameA()

◆ PdhLookupPerfIndexByNameW()

◆ PdhLookupPerfNameByIndexA()

◆ PdhLookupPerfNameByIndexW()

◆ PdhMakeCounterPathA()

◆ PdhMakeCounterPathW()

◆ PdhOpenQueryA()

◆ PdhOpenQueryW()

◆ PdhRemoveCounter()

◆ PdhSetCounterScaleFactor()

◆ PdhSetDefaultRealTimeDataSource()

◆ PdhValidatePathA()